notification.php

<?php
namespace Bitrix\Main\EventLog;
 
use Bitrix\Main;
use Bitrix\Main\ORM\Fields;
use Bitrix\Main\ORM\Objectify;
use Bitrix\Main\ORM\Query;
use Bitrix\Main\EventLog\Internal\EventLogTable;
 
class Notification
{
    protected $data;
    protected $eventCount = 0;
 
    public function __construct($id = 0)
    {
        if($id > 0)
        {
            $this->data = Internal\LogNotificationTable::wakeUpObject($id);
        }
        else
        {
            $this->data = Internal\LogNotificationTable::createObject();
        }
    }
 
    public function fill()
    {
        if($this->data->state <> Objectify\State::RAW)
        {
            $this->data->fill(Fields\FieldTypeMask::SCALAR);
        }
    }
 
    public function fillActions()
    {
        if($this->data->state <> Objectify\State::RAW)
        {
            $this->data->fillActions();
        }
    }
 
    public function save()
    {
        //save to DB, including the actions collection
        $result = $this->data->save();
 
        if($result->isSuccess())
        {
            $agent = static::getAgentName($this->getId());
 
            if($result instanceof Main\ORM\Data\UpdateResult)
            {
                \CAgent::RemoveAgent($agent, "main");
            }
            \CAgent::AddAgent($agent, "main", "N", $this->getCheckInterval()*60);
        }
 
        return $result;
    }
 
    public function delete()
    {
        $id = $this->getId();
 
        $result = $this->data->delete();
 
        if($result->isSuccess())
        {
            \CAgent::RemoveAgent(static::getAgentName($id), "main");
        }
 
        return $result;
    }
 
    public function setFromArray(array $values)
    {
        foreach($this->data->entity->getFields() as $fieldName => $field)
        {
            if(!isset($values[$fieldName]))
            {
                continue;
            }
            if($fieldName == "ID")
            {
                continue;
            }
            if(!($field instanceof Fields\ScalarField))
            {
                continue;
            }
 
            $value = $values[$fieldName];
            if($field instanceof Fields\BooleanField)
            {
                $value = ($value == "Y");
            }
            $this->data->set($fieldName, $value);
        }
    }
 
    public function setActionsFromArray(array $values)
    {
        //set the actions collection from the array
        if($this->data->state <> Objectify\State::RAW)
        {
            $this->data->removeAllActions();
        }
        foreach($values as $postAction)
        {
            if($postAction["ID"] > 0)
            {
                $action = Internal\LogNotificationActionTable::wakeUpObject($postAction["ID"]);
            }
            else
            {
                $action = Internal\LogNotificationActionTable::createObject();
            }
            $action->setNotificationType($postAction["NOTIFICATION_TYPE"]);
            $action->setRecipient($postAction["RECIPIENT"]);
            $action->setAdditionalText($postAction["ADDITIONAL_TEXT"]);
 
            $this->data->addToActions($action);
        }
    }
 
    public function getActions()
    {
        $actions = [];
        if(($collection = $this->data->getActions()))
        {
            foreach($collection as $record)
            {
                $actions[$record->getId()] = Action::createByType(
                    $record->getNotificationType(),
                    $record->getRecipient(),
                    $record->getAdditionalText()
                );
            }
        }
        return $actions;
    }
 
    public function __call($name, $arguments)
    {
        if(($first = substr($name, 0, 3)) == "get" || $first == "set")
        {
            return $this->data->__call($name, $arguments);
        }
 
        throw new Main\SystemException(sprintf(
            'Unknown method `%s` for object `%s`', $name, get_called_class()
        ));
    }
 
    public function setEventCount($n)
    {
        $this->eventCount = $n;
        return $this;
    }
 
    public function getEventCount()
    {
        return $this->eventCount;
    }
 
    public static function checkConditions($id)
    {
        $notification = new static($id);
        $notification->fill();
 
        if($notification->getAuditTypeId() == '')
        {
            //nonexistent
            return '';
        }
 
        $interval = intval($notification->getCheckInterval());
        $dateInterval = new Main\Type\DateTime();
        $dateInterval->add("-T{$interval}M");
 
        $notification->setDateChecked(new Main\Type\DateTime());
        $result = $notification->data->save();
        if(!$result->isSuccess())
        {
            return '';
        }
 
        $filter = Query\Query::filter()
            ->where("AUDIT_TYPE_ID", $notification->getAuditTypeId())
            ->where("TIMESTAMP_X", ">", $dateInterval);
 
        if($notification->getItemId() <> '')
        {
            $filter->whereLike("ITEM_ID", '%'.$notification->getItemId().'%');
        }
        if($notification->getUserId() > 0)
        {
            $filter->where("USER_ID", $notification->getUserId());
        }
        if($notification->getRemoteAddr() <> '')
        {
            $filter->whereLike("REMOTE_ADDR", '%'.$notification->getRemoteAddr().'%');
        }
        if($notification->getUserAgent() <> '')
        {
            $filter->whereLike("USER_AGENT", '%'.$notification->getUserAgent().'%');
        }
        if($notification->getRequestUri() <> '')
        {
            $filter->whereLike("REQUEST_URI", '%'.$notification->getRequestUri().'%');
        }
 
        $eventCount = EventLogTable::query()
            ->addSelect(new Fields\ExpressionField('CNT', 'COUNT(1)'))
            ->where($filter)
            ->fetch();
 
        if($eventCount["CNT"] >= $notification->getAlertCount())
        {
            //notification triggered
            $notification->setEventCount($eventCount["CNT"]);
            $notification->send();
        }
 
        return static::getAgentName($id);
    }
 
    public function send()
    {
        $this->fillActions();
        foreach($this->getActions() as $action)
        {
            $action->send($this);
        }
    }
 
    protected static function getAgentName($id)
    {
        return '\Bitrix\Main\EventLog\Notification::checkConditions('.$id.');';
    }
}