state.php

<?php
namespace Bitrix\Sender\Dispatch;
 
use Bitrix\Main\Application;
use Bitrix\Main\InvalidOperationException;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\NotImplementedException;
use Bitrix\Main\Type\Date;
use Bitrix\Main\Type\DateTime;
use Bitrix\Sender\Dispatch;
use Bitrix\Sender\Entity;
use Bitrix\Sender\Integration;
use Bitrix\Sender\Internals\Model;
use Bitrix\Sender\Posting;
use Bitrix\Sender\PostingRecipientTable;
use Bitrix\Sender\Transport\TimeLimiter;
 
Loc::loadMessages(__FILE__);
 
class State
{
    const NEWISH = 'N';
    const INIT = 'I';
    const READY = 'R';
    const SENDING = 'S';
    const WAITING = 'W';
    const PLANNED = 'T';
    const PAUSED = 'P';
    const SENT = 'Y';
    const STOPPED = 'X';
    const HALTED = 'H';
 
    private $letter;
 
    protected $dateTime;
 
    public function __construct(Entity\Letter $letter)
    {
        $this->letter = $letter;
    }
 
    public function isReady()
    {
        return in_array($this->getCode(), array(self::NEWISH, self::INIT, self::READY));
    }
 
    public function isSent()
    {
        return in_array($this->getCode(), array(self::SENT));
    }
 
    public function isFinished()
    {
        return in_array($this->getCode(), Semantics::getFinishStates());
    }
 
    public function isStopped()
    {
        return in_array($this->getCode(), array(self::STOPPED));
    }
 
    public function isWaiting()
    {
        return in_array($this->getCode(), [self::WAITING]);
    }
 
    public function isHalted()
    {
        return in_array($this->getCode(), [self::HALTED]);
    }
 
    public function isSending()
    {
        return in_array($this->getCode(), [self::SENDING]);
    }
 
    public function isPlanned()
    {
        return in_array($this->getCode(), array(self::PLANNED));
    }
 
    public function isPaused()
    {
        return in_array($this->getCode(), [self::PAUSED]);
    }
 
    public function wasStartedSending()
    {
        return in_array(
            $this->getCode(),
            array(
                self::SENDING,
                self::WAITING,
                self::PAUSED,
                self::SENT,
                self::STOPPED,
                self::HALTED,
            ));
    }
 
    public function wasPostingBuilt()
    {
        return in_array(
            $this->getCode(),
            array(
                self::PLANNED,
                self::SENDING,
                self::PAUSED,
                self::SENT,
                self::STOPPED,
            ));
    }
 
    public function isSendingLimitExceeded()
    {
        if (!$this->isSending())
        {
            return false;
        }
 
        $message = $this->letter->getMessage();
        return $message->getTransport()->isLimitsExceeded($message);
    }
 
    public function isSendingLimitTemporary()
    {
        if (!$this->isSending())
        {
            return false;
        }
 
        $message = $this->letter->getMessage();
        $limiter = $message->getTransport()->getExceededLimiter($message);
        
        if (!$limiter)
        {
            return false;
        }
        
        return $limiter->getParameter('temporaryLimit') === true;
    }
 
    public function isSendingLimitWaiting()
    {
        if (!$this->isSending())
        {
            return false;
        }
 
        $message = $this->letter->getMessage();
        return $message->getTransport()->getExceededLimiter($message) instanceof TimeLimiter;
    }
 
    public function isSendingPlanned()
    {
        if (!$this->isSending())
        {
            return false;
        }
 
        $plannedDateSend = $this->getPlannedDateSend();
        if (!$plannedDateSend)
        {
            return false;
        }
        $dateNow = new DateTime();
 
        return $plannedDateSend->getTimestamp() > $dateNow->getTimestamp();
    }
 
    public function getDateSend()
    {
        return $this->letter->get('DATE_SEND');
    }
 
    public function getDatePause()
    {
        return $this->letter->get('DATE_PAUSE');
    }
 
    public function getDateSent()
    {
        return $this->letter->get('DATE_SENT');
    }
 
    public function getDateCreate()
    {
        return $this->letter->get('DATE_INSERT');
    }
 
    public function getPlannedDateSend()
    {
        return $this->letter->get('AUTO_SEND_TIME');
    }
 
    public function getLastExecutedDate()
    {
        return $this->letter->get('LAST_EXECUTED');
    }
 
    public function updatePlannedDateSend(Date $date)
    {
        \CTimeZone::disable();
        $result = Model\LetterTable::update($this->letter->getId(), array('AUTO_SEND_TIME' => $date));
        \CTimeZone::enable();
        if ($result->isSuccess())
        {
            $this->letter->set('AUTO_SEND_TIME', $date);
        }
 
        return $result->isSuccess();
    }
 
    protected function updateDateSend()
    {
        return $this->updateDate('DATE_SEND');
    }
 
    protected function updateDatePause()
    {
        return $this->updateDate('DATE_PAUSE');
    }
 
    protected function updateDateSent()
    {
        return $this->updateDate('DATE_SENT');
    }
 
    protected function updateDate($name, $date = null)
    {
        if (!$this->letter->get('POSTING_ID'))
        {
            return false;
        }
        \CTimeZone::disable();
        $result = Model\PostingTable::update(
            $this->letter->get('POSTING_ID'),
            array(
                $name => ($date ?: new DateTime())
            )
        );
        \CTimeZone::enable();
 
        return $result->isSuccess();
    }
 
    public function getCode()
    {
        $map = self::getStatusMap();
        $status = $this->letter->get('STATUS');
 
        if (($status && isset($map[$status])))
        {
            return $map[$status];
        }
 
        return self::NEWISH;
    }
 
    public function getName()
    {
        /*
        if ($this->isSendingPlanned())
        {
            return Loc::getMessage('SENDER_DISPATCH_STATE_T');
        }
        */
 
        return self::getStateName($this->getCode());
    }
 
    protected static function getStateName($code)
    {
//      $code = $code === self::NEWISH ? self::READY : $code;
        return Loc::getMessage('SENDER_DISPATCH_STATE1_' . $code) ?: Loc::getMessage('SENDER_DISPATCH_STATE_' . $code);
    }
 
    public static function getList()
    {
        $class = new \ReflectionClass(__CLASS__);
        $constants = $class->getConstants();
 
        $list = array();
        foreach ($constants as $id => $value)
        {
            if (in_array($value, array(self::INIT)))
            {
                continue;
            }
 
            $list[$value] = self::getStateName($value);
        }
 
        return $list;
    }
 
    public function plan(Date $sendDate)
    {
        return $this->changeState(self::PLANNED, $sendDate);
    }
 
    public function ready()
    {
        return $this->changeState(self::READY);
    }
 
    public function send()
    {
        return $this->changeState(self::SENDING);
    }
 
    public function sendErrors()
    {
        if (!$this->canSendErrors())
        {
            throw new InvalidOperationException('Can not resend error letters.');
        }
 
        $postingId = $this->letter->get('POSTING_ID');
        $updateSql = 'UPDATE ' . PostingRecipientTable::getTableName() .
            " SET STATUS='" . PostingRecipientTable::SEND_RESULT_NONE . "'" .
            " WHERE POSTING_ID=" . intval($postingId) .
            " AND STATUS='" . PostingRecipientTable::SEND_RESULT_ERROR . "'";
        Application::getConnection()->query($updateSql);
        Posting\Sender::updateActualStatus($this->letter->get('POSTING_ID'));
 
        return $this->updateStatus(Model\LetterTable::STATUS_SEND, self::SENDING);
    }
 
    public function pause()
    {
        if ($this->changeState(self::PAUSED))
        {
            $this->updateDatePause(); //TODO: move to tablet!
            return true;
        }
 
        return false;
    }
 
    public function halt()
    {
        if ($this->changeState(self::HALTED))
        {
            $this->updateDatePause(); //TODO: move to tablet!
            return true;
        }
 
        return false;
    }
 
    public function resume()
    {
        if ($this->changeState(self::SENDING))
        {
            $this->updateDateSend(); //TODO: move to tablet!
            return true;
        }
 
        return false;
    }
 
    public function stop()
    {
        if ($this->changeState(self::STOPPED))
        {
            $this->updateDateSent(); //TODO: move to tablet!
            return true;
        }
 
        return false;
    }
 
    public function init()
    {
        return $this->changeState(self::INIT);
    }
 
    public function reset()
    {
        throw new NotImplementedException('init reset not implemented.');
    }
 
    public function wait(Dispatch\MethodSchedule $method = null)
    {
        return $this->changeState(self::WAITING, $method ? $method->getNextDate() : null);
    }
 
    public function canReady()
    {
        return $this->canChangeState(self::READY);
    }
 
    public function canSend()
    {
        if ($this->getCode() === self::PAUSED)
        {
            return false;
        }
 
        return $this->canChangeState(self::SENDING);
    }
 
    public function canSendErrors()
    {
        if (Integration\Bitrix24\Service::isCloud())
        {
            return false;
        }
 
        if ($this->letter->isTrigger() || $this->letter->isReiterate())
        {
            return false;
        }
 
        if (!$this->letter->isSupportHeatMap() || !$this->letter->get('POSTING_ID'))
        {
            return false;
        }
 
        if (!$this->isSent())
        {
            return false;
        }
 
        $postingData = $this->letter->getLastPostingData();
        return !empty($postingData['COUNT_SEND_ERROR']);
    }
 
    public function canPlan()
    {
        return $this->canChangeState(self::SENDING);
    }
 
    public function canPause()
    {
        return $this->canChangeState(self::PAUSED);
    }
 
    public function canStop()
    {
        return $this->canChangeState(self::STOPPED);
    }
 
    public function canResume()
    {
        if ($this->getCode() !== self::PAUSED)
        {
            return false;
        }
 
        return $this->canChangeState(self::SENDING);
    }
 
    public function canReset()
    {
        return $this->canChangeState(self::NEWISH);
    }
 
    public function canInit()
    {
        return $this->canChangeState(self::INIT);
    }
 
    public function canWait()
    {
        return $this->canChangeState(self::WAITING);
    }
 
    public function canHalt()
    {
        return $this->canChangeState(self::HALTED);
    }
 
    protected function getPossibleStates()
    {
        switch ($this->getCode())
        {
            case self::NEWISH:
                return array(
                    self::INIT,
                    self::SENDING,
                    self::PLANNED,
                    self::WAITING,
                );
            case self::INIT:
                return array(
                    self::READY,
                );
            case self::READY:
                return array(
                    self::SENDING,
                    self::PLANNED,
                    self::WAITING,
                );
            case self::PLANNED:
                return array(
                    self::READY,
                    self::PLANNED,
                    self::SENDING,
                    self::SENT,
                    self::STOPPED,
                );
            case self::SENDING:
                return array(
                    self::PAUSED,
                    self::SENT,
                    self::STOPPED,
                    self::WAITING,
                );
            case self::PAUSED:
                return array(
                    self::SENDING,
                    self::SENT,
                    self::STOPPED,
                    self::WAITING,
                );
            case self::WAITING:
                return array(
                    self::SENT,
                    self::WAITING,
                    self::HALTED,
                    self::STOPPED,
                    self::READY,
                );
            case self::HALTED:
                return [
                    self::WAITING,
                    self::STOPPED,
                ];
            case self::STOPPED:
            case self::SENT:
            default:
                return [];
        }
    }
 
    private function canChangeState($state)
    {
        if (!$this->letter->getId())
        {
            return false;
        }
 
        return $this->isPossibleState($state);
    }
 
    private function changeState($state, Date $sendDate = null)
    {
        if (!$this->isCampaignActive() && in_array($state, [self::SENDING, self::PLANNED]))
        {
            throw new InvalidOperationException(Loc::getMessage('SENDER_DISPATCH_STATE_ERROR_CAMPAIGN_INACTIVE'));
        }
 
        if (!$this->canChangeState($state))
        {
            $messageText = Loc::getMessage('SENDER_DISPATCH_STATE_ERROR_CHANGE', array(
                '%old%' => $this->getName(),
                '%new%' => self::getStateName($state)
            ));
 
            throw new InvalidOperationException($messageText);
        }
 
        $map = self::getStateMap();
        if ($map[$state])
        {
            return $this->updateStatus($map[$state], $state, $sendDate);
        }
 
        return false;
    }
 
    private function isPossibleState($state)
    {
        $possibleStates = $this->getPossibleStates();
 
        //TODO: remove
        if (!$this->letter->isSupportReiterate() && !$this->letter->isTrigger())
        {
            $possibleStates = array_filter($possibleStates, function ($value)
            {
                return  !in_array($value, [self::WAITING, self::HALTED]);
            });
        }
 
        return in_array($state, $possibleStates);
    }
 
    private function updateStatus($status, $state, Date $sendDate = null)
    {
        $fields = array('STATUS' => $status);
        if ($state === self::READY && $this->letter->get('AUTO_SEND_TIME'))
        {
            $fields['AUTO_SEND_TIME'] = null;
        }
        if ($state === self::SENDING)
        {
            $fields['AUTO_SEND_TIME'] = $sendDate ?: new DateTime();
        }
        if ($state === self::PLANNED)
        {
            $fields['AUTO_SEND_TIME'] = $sendDate ?: new DateTime();
        }
        if ($state === self::WAITING && $sendDate)
        {
            $fields['AUTO_SEND_TIME'] = $sendDate;
        }
        if ($updatedBy = $this->letter->get('UPDATED_BY'))
        {
            $fields['UPDATED_BY'] = $updatedBy;
        }
        \CTimeZone::disable();
        $result = Model\LetterTable::update($this->letter->getId(), $fields);
        \CTimeZone::enable();
 
        if ($result->isSuccess())
        {
            $this->letter->set('STATUS', $status);
            if (isset($fields['AUTO_SEND_TIME']))
            {
                $this->letter->set('AUTO_SEND_TIME', $fields['AUTO_SEND_TIME']);
            }
        }
        else
        {
            $this->letter->getErrorCollection()->add($result->getErrors());
        }
 
        return $result->isSuccess();
    }
 
    private static function getStateMap()
    {
        $map = array_flip(self::getStatusMap());
        $map[self::INIT] = Model\LetterTable::STATUS_NEW; // for init-operation
 
        return $map;
    }
 
    private static function getStatusMap()
    {
        return array(
            Model\LetterTable::STATUS_NEW => self::NEWISH,
            Model\LetterTable::STATUS_PLAN => self::PLANNED,
            Model\LetterTable::STATUS_READY => self::READY,
            Model\LetterTable::STATUS_SEND => self::SENDING,
            Model\LetterTable::STATUS_WAIT => self::WAITING,
            Model\LetterTable::STATUS_HALT => self::HALTED,
            Model\LetterTable::STATUS_PAUSE => self::PAUSED,
            Model\LetterTable::STATUS_END => self::SENT,
            Model\LetterTable::STATUS_CANCEL => self::STOPPED,
        );
    }
 
    private function isCampaignActive()
    {
        return $this->letter->get('CAMPAIGN_ACTIVE', 'Y') === 'Y';
    }
}