segment.php

<?php
namespace Bitrix\Sender\Entity;
 
use Bitrix\Main\Application;
use Bitrix\Main\Error;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Type\DateTime;
use Bitrix\Sender\Connector;
use Bitrix\Sender\ContactTable;
use Bitrix\Sender\GroupConnectorTable;
use Bitrix\Sender\GroupDealCategoryTable;
use Bitrix\Sender\GroupTable;
use Bitrix\Sender\Internals\Model\GroupCounterTable;
use Bitrix\Sender\ListTable;
use Bitrix\Sender\Posting\SegmentDataBuilder;
use Bitrix\Main\Type;
 
Loc::loadMessages(__FILE__);
Loc::loadMessages(__DIR__ . '/letter.php');
 
class Segment extends Base
{
    const CODE_ALL = 'all';
 
    protected $isFilterOnly = false;
 
    public static function getDefaultIds()
    {
        $result = array();
        $id = self::getIdByCode(self::CODE_ALL);
        if ($id)
        {
            $result[] = $id;
        }
 
        return $result;
    }
 
    public static function getIdByCode($code)
    {
        $row = self::getList(array(
            'select' => array('ID'),
            'filter' => array('=CODE' => $code),
            'limit' => 1,
            'cache' => array('ttl' => 36000)
        ))->fetch();
 
        return $row ? $row['ID'] : null;
    }
 
    public static function getList(array $parameters = array())
    {
        return GroupTable::getList($parameters);
    }
 
    protected function getDefaultData()
    {
        return array(
            'NAME' => '',
            'ENDPOINTS' => array(),
        );
    }
 
    protected function loadData($id)
    {
        $data = GroupTable::getRowById($id);
        if (!is_array($data))
        {
            return null;
        }
 
        $data['ENDPOINTS'] = array();
        $groupConnectorDb = GroupConnectorTable::getList(array(
            'filter'=>array(
                '=GROUP_ID'=> $id
            )
        ));
        while($groupConnector = $groupConnectorDb->fetch())
        {
            if(empty($groupConnector['ENDPOINT']) || !is_array($groupConnector['ENDPOINT']))
            {
                continue;
            }
 
            $groupConnector['ENDPOINT']['FILTER_ID'] = $groupConnector['FILTER_ID'];
            $data['ENDPOINTS'][] = $groupConnector['ENDPOINT'];
        }
 
        return $data;
    }
 
    protected function saveData($id, array $data)
    {
        $endpoints = $data['ENDPOINTS'];
        unset($data['ENDPOINTS']);
 
        if (!$id
            && isset($data['STATUS'])
            && $data['STATUS'] !== GroupTable::STATUS_NEW)
        {
            $data['STATUS'] = GroupTable::STATUS_DONE;
        }
 
        $id = $this->saveByEntity(GroupTable::getEntity(), $id, $data);
        if ($this->hasErrors())
        {
            return $id;
        }
 
        $dataCounters = array();
        GroupConnectorTable::delete(array('GROUP_ID' => $id));
 
        if ($endpoints)
        {
            foreach ($endpoints as $endpoint)
            {
                $connector = Connector\Manager::getConnector($endpoint);
                if (!$connector)
                {
                    continue;
                }
 
                if ($this->isFilterOnly() && !($connector instanceof Connector\BaseFilter))
                {
                    continue;
                }
 
                $connector->setFieldValues(is_array($endpoint['FIELDS']) ? $endpoint['FIELDS'] : null);
                $endpoint['FIELDS'] = $connector->getFieldValues();
                $statFields = $connector->getStatFields();
 
                foreach (array_intersect($statFields, array_keys($endpoint['FIELDS'])) as $field)
                {
                    \Bitrix\Sender\Log::stat('segment_field', $field, $id);
                }
                $isIncrementally = $connector instanceof Connector\IncrementallyConnector;
 
                $dataCounter = $isIncrementally
                    ? new Connector\DataCounter([])
                    : $connector->getDataCounter();
 
                $groupConnector = array(
                    'GROUP_ID' => $id,
                    'NAME' => $connector->getName(),
                    'ENDPOINT' => $endpoint,
                    'ADDRESS_COUNT' => $dataCounter->getSummary()
                );
 
                if(isset($endpoint['FILTER_ID']))
                {
                    $groupConnector['FILTER_ID'] = $endpoint['FILTER_ID'];
                }
 
                $connectorResultDb = GroupConnectorTable::add($groupConnector);
                if($connectorResultDb->isSuccess())
                {
                    $dataCounters[] = $dataCounter;
                }
 
                $this->updateDealCategory($id, $connector);
            }
 
            if (isset($data['STATUS']) && GroupTable::STATUS_NEW === $data['STATUS'])
            {
                SegmentDataBuilder::actualize($id, true);
            }
 
            SegmentDataBuilder::checkIsSegmentPrepared($id);
            $this->updateAddressCounters($id, $dataCounters);
        }
 
        return $id;
    }
 
    private function updateDealCategory(int $groupId, $connector)
    {
        $groupDealCategory = [];
 
        foreach ($connector->getFieldValues() as $fieldKey => $fieldValue)
        {
            if($fieldKey != 'DEAL_CATEGORY_ID')
            {
                continue;
            }
            GroupDealCategoryTable::deleteList(array('GROUP_ID' => $groupId));
 
            foreach ($fieldValue as $dealCategory)
            {
                $groupDealCategory[] = [
                    'GROUP_ID' => $groupId,
                    'DEAL_CATEGORY_ID' => $dealCategory
                ];
            }
        }
 
        if(!empty($groupDealCategory))
        {
            GroupDealCategoryTable::addMulti($groupDealCategory);
        }
    }
 
    public function isHidden()
    {
        return $this->get('HIDDEN') === 'Y';
    }
 
    public function isSystem()
    {
        return $this->get('IS_SYSTEM') === 'Y';
    }
 
    public function isFilterOnly()
    {
        return $this->isFilterOnly;
    }
 
    public function setFilterOnlyMode($mode = true)
    {
        $this->isFilterOnly = $mode;
        return $this;
    }
 
    public function appendContactSetConnector($contactSetId = null)
    {
        if ($this->getFirstContactSetId())
        {
            return $this;
        }
 
        if (!$contactSetId)
        {
            $contactSetId = ListTable::add(['SORT' => 100])->getId();
        }
        elseif (!ListTable::getRowById($contactSetId))
        {
            $this->errors->setError(new Error('Wrong contact set ID.'));
            return $this;
        }
 
        $this->data['ENDPOINTS'][] = [
            'MODULE_ID' => 'sender',
            'CODE' => 'contact_list',
            'FIELDS' => [
                'LIST_ID' => $contactSetId,
                'SENDER_SELECT_ALL' => null,
            ],
        ];
        return $this;
    }
 
    protected function getFirstContactSetId()
    {
        foreach ($this->data['ENDPOINTS'] as $endpoint)
        {
            if ($endpoint['MODULE_ID'] !== 'sender' || $endpoint['CODE'] !== 'contact_list')
            {
                continue;
            }
 
            if (empty($endpoint['FIELDS']['LIST_ID']))
            {
                continue;
            }
 
            return $endpoint['FIELDS']['LIST_ID'];
        }
 
        return null;
    }
 
    public function upload(array $list)
    {
        $contactSetId = $this->getFirstContactSetId();
        if (!$contactSetId)
        {
            $this->appendContactSetConnector()->save();
        }
 
        $contactSetId = $this->getFirstContactSetId();
        if (!$contactSetId)
        {
            $this->errors->setError(new Error('Contact set not found.'));
            return $this;
        }
 
        ContactTable::upload($list, false, $contactSetId);
 
        return $this;
    }
 
    public static function updateAddressCounters($segmentId, array $counters)
    {
        if (!$segmentId)
        {
            return false;
        }
 
        $count = 0;
        $countByType = array();
        foreach ($counters as $dataCounter)
        {
            $count += $dataCounter->getSummary();
            $list = $dataCounter->getList();
            foreach ($list as $typeId => $typeCount)
            {
                if (!isset($countByType[$typeId]))
                {
                    $countByType[$typeId] = 0;
                }
 
                $countByType[$typeId] += $typeCount;
            }
        }
 
 
        $result = GroupTable::update($segmentId, array('ADDRESS_COUNT' => $count));
        if (!$result->isSuccess())
        {
            return false;
        }
 
        GroupCounterTable::deleteByGroupId($segmentId);
        foreach ($countByType as $typeId => $typeCount)
        {
            if (!$typeCount)
            {
                continue;
            }
 
            GroupCounterTable::add(array(
                'GROUP_ID' => $segmentId,
                'TYPE_ID' => $typeId,
                'CNT' => $typeCount,
            ));
        }
 
        return true;
    }
 
    public static function getAddressCounter($segmentId)
    {
        $data = self::getAddressCounters(array($segmentId));
        return new Connector\DataCounter(current($data) ?: array());
    }
 
    public static function getAddressCounters(array $list)
    {
        $data = array();
        $list = GroupCounterTable::getList(array(
            'select' => array('GROUP_ID', 'TYPE_ID', 'CNT'),
            'filter' => array('=GROUP_ID' => $list),
            'order' => array('GROUP_ID' => 'ASC')
        ));
        foreach ($list as $row)
        {
            $data[$row['GROUP_ID']][$row['TYPE_ID']] = $row['CNT'];
        }
        return $data;
    }
 
    public static function updateUseCounters(array $list, $isInclude = true)
    {
        if (count($list) === 0)
        {
            return;
        }
 
        $tableName = GroupTable::getTableName();
        $now = Application::getConnection()->getSqlHelper()->convertToDbDateTime(new DateTime());
        $ids = array();
        foreach ($list as $element)
        {
            $id = $element['ID'];
            if (!$id || !is_numeric($id))
            {
                continue;
            }
 
            $id = (int) $id;
            if (!$id)
            {
                continue;
            }
 
            $ids[] = $id;
        }
        $ids = implode(', ', $ids);
        $postfix = $isInclude ? '' : '_EXCLUDE';
 
        $sql = "UPDATE $tableName SET USE_COUNT$postfix = USE_COUNT$postfix + 1, DATE_USE$postfix = $now WHERE ID IN ($ids)";
        Application::getConnection()->query($sql);
    }
 
    public function remove()
    {
        return $this->removeByEntity(GroupTable::getEntity(), $this->getId());
    }
 
    public function copy()
    {
        $data = $this->loadData($this->getId());
 
        return $this->copyData(
            $this->getId(),
            [
                'NAME' => Loc::getMessage('SENDER_ENTITY_LETTER_COPY_PREFIX') . ' ' .$data['NAME'],
                'CODE' => null,
                'STATUS' => GroupTable::STATUS_NEW,
                'DATE_USE' => null,
                'USE_COUNT' => 0,
                'USE_COUNT_EXCLUDE' => 0,
                'DATE_INSERT' => new Type\DateTime(),
            ]
        );
    }
 
    public static function removeById($id)
    {
        return static::create()->removeByEntity(GroupTable::getEntity(), $id);
    }
}