group.php

См. документацию.

<?php
 
namespace Bitrix\Socialnetwork\Copy\Implement;
 
use Bitrix\Main\AccessDeniedException;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Copy\Container;
use Bitrix\Main\Copy\CopyImplementer;
use Bitrix\Main\Error;
use Bitrix\Main\Loader;
use Bitrix\Main\Result;
use Bitrix\Main\Text\Emoji;
use Bitrix\Socialnetwork\Copy\Integration\Feature;
use Bitrix\Socialnetwork\Permission\GroupAccessController;
use Bitrix\Socialnetwork\Permission\GroupDictionary;
use Bitrix\Socialnetwork\Permission\Model\GroupModel;
use Bitrix\Socialnetwork\WorkgroupSiteTable;
 
class Group extends CopyImplementer
{
    const GROUP_COPY_ERROR = "GROUP_COPY_ERROR";
 
    protected $executiveUserId;
 
    private $changedFields = [];

    private $features = [];
 
    private $projectTerm = [];

    private $userGroupHelper = null;
 
    public function __construct($executiveUserId)
    {
        parent::__construct();
 
        $this->executiveUserId = $executiveUserId;
    }

    public function setFeature(Feature $feature)
    {
        $this->features[] = $feature;
    }

    public function setProjectTerm(array $projectTerm)
    {
        $this->projectTerm = $projectTerm;
    }
 
    public function setChangedFields($changedFields)
    {
        $this->changedFields = array_merge($this->changedFields, $changedFields);
    }

    public function setUserGroupHelper(UserGroupHelper $userGroupHelper)
    {
        $this->userGroupHelper = $userGroupHelper;
    }
 
    public function add(Container $container, array $fields)
    {
        $accessController = GroupAccessController::getInstance($this->executiveUserId);
        $groupModel = GroupModel::createFromArray(['siteIds' => $fields['SITE_ID']]);
 
        if (!$accessController->check(GroupDictionary::CREATE, $groupModel))
        {
            throw new AccessDeniedException();
        }
 
        $groupId = \CSocNetGroup::createGroup($this->executiveUserId, $fields, false);
 
        if (!$groupId)
        {
            global $APPLICATION;
 
            $this->result->addError(
                new Error(
                    $APPLICATION->GetException()
                        ? $APPLICATION->GetException()->GetString()
                        : 'System error'
                    ,
                    self::GROUP_COPY_ERROR
                )
            );
        }
        else
        {
            \CSocNetFeatures::setFeature(SONET_ENTITY_GROUP, $groupId, "files", true, false);
 
            if (isset($fields["OWNER_ID"]))
            {
                if (\CSocNetUserToGroup::setOwner($fields["OWNER_ID"], $groupId))
                {
                    $dictionary = $container->getDictionary();
 
                    $dictionary["NEW_OWNER_ID"] = $fields["OWNER_ID"];
 
                    $container->setDictionary($dictionary);
                }
            }
 
            if ($this->userGroupHelper)
            {
                $this->userGroupHelper->changeModerators($groupId);
            }
        }
 
        return $groupId;
    }
 
    public function getFields(Container $container, $entityId)
    {
        $fields = [];
 
        $queryObject = \CSocNetGroup::getList(
            ["ID" => "DESC"], ["ID" => (int) $entityId], false, false, ["*"]);
        while ($group = $queryObject->fetch())
        {
            if ($group["IMAGE_ID"] > 0)
            {
                $group["IMAGE_ID"] = \CFile::makeFileArray($group["IMAGE_ID"]);
            }
            if (!empty($group['NAME']))
            {
                $group['NAME'] = Emoji::decode($group['NAME']);
            }
            if (!empty($group['DESCRIPTION']))
            {
                $group['DESCRIPTION'] = Emoji::decode($group['DESCRIPTION']);
            }
 
            $fields["SITE_ID"] = $this->getSiteIds($group["ID"]);
 
            $fields = $group;
        }
 
        return $fields;
    }
 
    public function prepareFieldsToCopy(Container $container, array $fields)
    {
        if (!empty($this->changedFields))
        {
            $fields = $this->changeFields($fields);
        }
 
        if ($fields["PROJECT"] == "Y" && $this->projectTerm)
        {
            if (!empty($this->projectTerm["start_point"]) && !empty($this->projectTerm["end_point"]))
            {
                $fields = $this->getFieldsProjectTerm($fields);
            }
            elseif (!empty($this->projectTerm["start_point"]))
            {
                $fields = $this->getRecountFieldsProjectTerm($fields, $this->projectTerm["start_point"]);
            }
        }
 
        $fields = $this->prepareExtranetFields($fields);
 
        unset($fields["ID"]);
        unset($fields["DATE_CREATE"]);
        unset($fields["DATE_UPDATE"]);
        unset($fields["DATE_ACTIVITY"]);
 
        return $fields;
    }

    public function copyChildren(Container $container, $groupId, $copiedGroupId)
    {
        $copiedGroupId = (int) $copiedGroupId;
        if (!$copiedGroupId)
        {
            return new Result();
        }
 
        $this->copyUfFields($groupId, $copiedGroupId, "SONET_GROUP");
 
        foreach ($this->features as $feature)
        {
            //todo Perhaps it’s worth making the parameters not in the array, but in the object.
            // Until I made a decision, I do not want to write this to the interface.
            if (method_exists($feature, "setProjectTerm"))
            {
                $feature->setProjectTerm($this->projectTerm);
            }
            $feature->copy($groupId, $copiedGroupId);
        }
 
        $this->copyFeatures($groupId, $copiedGroupId);
 
        return $this->getResult();
    }
 
    private function changeFields(array $fields)
    {
        foreach ($this->changedFields as $fieldId => $fieldValue)
        {
            if (array_key_exists($fieldId, $fields))
            {
                $fields[$fieldId] = $fieldValue;
            }
        }
 
        return $fields;
    }
 
    private function getFieldsProjectTerm($fields)
    {
        try
        {
            $projectTerm = [
                "project" => true
            ];
 
            $startPoint = $this->projectTerm["start_point"];
            $endPoint = $this->projectTerm["end_point"];
 
            $phpDateFormat = \Bitrix\Main\Type\DateTime::convertFormatToPhp(FORMAT_DATE);
 
            $newDateStart = new \DateTime($startPoint);
            $fields["PROJECT_DATE_START"] = $newDateStart->format($phpDateFormat);
 
            $newDateEnd = new \DateTime($endPoint);
            $fields["PROJECT_DATE_FINISH"] = $newDateEnd->format($phpDateFormat);
 
            $projectTerm["start_point"] = $fields["PROJECT_DATE_START"];
            $projectTerm["end_point"] = $fields["PROJECT_DATE_FINISH"];
 
            $this->setProjectTerm($projectTerm);
        }
        catch (\Exception $exception)
        {
            $fields["PROJECT_DATE_FINISH"] = "";
            $this->result->addError(new Error($exception->getMessage()));
        }
 
        return $fields;
    }
 
    private function getRecountFieldsProjectTerm($fields, $startPoint)
    {
        try
        {
            $projectTerm = [
                "project" => true,
                "old_start_point" => $fields["PROJECT_DATE_START"]
            ];
 
            $oldDateStart = new \DateTime($fields["PROJECT_DATE_START"]);
 
            $phpDateFormat = \Bitrix\Main\Type\DateTime::convertFormatToPhp(FORMAT_DATE);
 
            $newDateStart = new \DateTime($startPoint);
            $fields["PROJECT_DATE_START"] = $newDateStart->format($phpDateFormat);
 
            if (!empty($fields["PROJECT_DATE_FINISH"]))
            {
                $dateFinish = new \DateTime($fields["PROJECT_DATE_FINISH"]);
                $interval = new \DateInterval("PT".($dateFinish->getTimestamp()-$oldDateStart->getTimestamp())."S");
                $newDateStart->add($interval);
                $fields["PROJECT_DATE_FINISH"] = $newDateStart->format($phpDateFormat);
            }
 
            $projectTerm["start_point"] = $fields["PROJECT_DATE_START"];
            $projectTerm["end_point"] = $fields["PROJECT_DATE_FINISH"];
 
            $this->setProjectTerm($projectTerm);
        }
        catch (\Exception $exception)
        {
            $fields["PROJECT_DATE_FINISH"] = "";
            $this->result->addError(new Error($exception->getMessage()));
        }
 
        return $fields;
    }
 
    private function prepareExtranetFields(array $fields): array
    {
        if (!Loader::includeModule('extranet'))
        {
            return $fields;
        }
 
        $isAllowCreateExtranetGroup = $this->isAllowCreateExtranetGroup();
        $existsExtranetSiteId = $this->isExtranetSite($fields['SITE_ID']);
 
        if ($isAllowCreateExtranetGroup)
        {
            $wantedExtranetGroup = $this->changedFields['IS_EXTRANET_GROUP'] === 'Y';
 
            if ($wantedExtranetGroup && !$existsExtranetSiteId)
            {
                $fields['SITE_ID'][] = \CExtranet::getExtranetSiteID();
                $fields['VISIBLE'] = 'N';
                $fields['OPENED'] = 'N';
            }
        }
        elseif ($existsExtranetSiteId)
        {
            $fields['SITE_ID'] = $this->getSiteIds($fields['ID']);
 
            $extranetSiteId = \CExtranet::getExtranetSiteID();
            $fields['SITE_ID'] = array_filter($fields['SITE_ID'], static fn($siteId) => $siteId !== $extranetSiteId);
        }
 
        if (empty($fields['SITE_ID']))
        {
            throw new \InvalidArgumentException('Site id cannot be empty');
        }
 
        return $fields;
    }
 
    private function isAllowCreateExtranetGroup(): bool
    {
        $isExtranetForGroupsEnabled = (bool)Option::get('socialnetwork', 'enable_extranet_for_groups', 0);
 
        return Loader::includeModule('extranet') && $isExtranetForGroupsEnabled;
    }
 
    private function getSiteIds(int $groupId): array
    {
        $siteIds = [];
 
        $queryObject = WorkgroupSiteTable::getList([
            "filter" => [
                "GROUP_ID" => $groupId
            ],
            "select" => ["SITE_ID"]
        ]);
        while ($workGroupSite = $queryObject->fetch())
        {
            $siteIds[] = $workGroupSite["SITE_ID"];
        }
        $siteIds = array_unique($siteIds);
 
        return $siteIds;
    }
 
    private function isExtranetSite(array $siteIds): bool
    {
        foreach ($siteIds as $siteId)
        {
            if (\CExtranet::isExtranetSite($siteId))
            {
                return true;
            }
        }
 
        return false;
    }
 
    private function copyFeatures(int $groupId, int $copiedGroupId): void
    {
        $featuresMapIds = [];
 
        $queryObject = \CSocNetFeatures::getList(
            [],
            [
                "ENTITY_ID" => $groupId,
                "ENTITY_TYPE" => SONET_ENTITY_GROUP
            ]
        );
        while ($feature = $queryObject->fetch())
        {
            $copiedFeatureId = \CSocNetFeatures::setFeature(
                SONET_ENTITY_GROUP,
                $copiedGroupId,
                $feature["FEATURE"],
                ($feature["ACTIVE"] == "Y"),
                false
            );
 
            if (is_numeric($copiedFeatureId))
            {
                $featuresMapIds[$feature["ID"]] = $copiedFeatureId;
            }
        }
 
        if ($featuresMapIds)
        {
            $this->copyFeaturesPerms($groupId, $featuresMapIds);
        }
    }
 
    private function copyFeaturesPerms(int $groupId, array $featuresMapIds): void
    {
        $queryObject = \CSocNetFeaturesPerms::getList(
            [],
            [
                'FEATURE_ENTITY_ID' => $groupId,
            ],
        );
        while ($permFields = $queryObject->fetch())
        {
            if (array_key_exists($permFields['FEATURE_ID'], $featuresMapIds))
            {
                \CSocNetFeaturesPerms::setPerm(
                    $featuresMapIds[$permFields['FEATURE_ID']],
                    $permFields['OPERATION_ID'],
                    $permFields['ROLE']
                );
            }
        }
    }
}