form.php

<?php
 
namespace Bitrix\Seo\LeadAds;
 
use Bitrix\Main\Context;
use Bitrix\Seo\LeadAds;
use Bitrix\Seo\Retargeting\BaseApiObject;
use Bitrix\Seo\Retargeting\Response;
use Bitrix\Seo\WebHook;
use Bitrix\Seo\Retargeting;
 
abstract class Form extends BaseApiObject
{
    public const URL_FORM_LIST = '';
    public const USE_GROUP_AUTH = false;
    public const FIELD_MAP = [];
 
    protected static $listRowMap = array(
        'ID' => 'ID',
        'NAME' => 'NAME',
    );
 
    protected $accountId;
 
    protected $formId;
 
    public function __construct(string $accountId = null)
    {
        $this->accountId = $accountId;
        parent::__construct();
    }
 
    public function setAccountId(string $accountId): Form
    {
        $this->accountId = $accountId;
 
        return $this;
    }
 
    public function getAccountId(): ?string
    {
        return $this->accountId;
    }
 
    protected static function getFieldMapper(): Mapper
    {
        static $mapper;
        return $mapper = $mapper ?? new LeadAds\Mapper(static::FIELD_MAP);
    }
 
 
    abstract public function getForm($formId):  LeadAds\Response\FormResponse;
 
    abstract public function getList(): LeadAds\Response\FormResponse;
 
    abstract public function getResult(WebHook\Payload\LeadItem $item): Result;
 
    abstract public function add(array $data): Response;
 
    abstract public function register($formId): Retargeting\Response;
 
    abstract public function unlink(string $id): bool;
 
 
    public function getRegisteredGroups(): array
    {
        $rows = Internals\CallbackSubscriptionTable::getList([
            'select' => ['GROUP_ID'],
            'filter' => [
                '=TYPE' => static::TYPE_CODE,
            ]
        ])->fetchAll();
 
        return array_column($rows, 'GROUP_ID');
    }
 
    public function unRegisterGroup(string $groupId) : bool
    {
        $row = Internals\CallbackSubscriptionTable::getRow([
            'filter' => [
                '=TYPE' => static::TYPE_CODE,
                '=GROUP_ID' => $groupId
            ]
        ]);
 
        return $row && Internals\CallbackSubscriptionTable::delete($row['ID'])->isSuccess();
    }
 
    public function registerGroup(string $groupId): bool
    {
        $hasGroup = false;
 
        $list = Internals\CallbackSubscriptionTable::getList([
            'filter' => [
                '=TYPE' => static::TYPE_CODE
            ]
        ]);
        foreach ($list as $row)
        {
            if ($row['GROUP_ID'] === $groupId)
            {
                $hasGroup = true;
                continue;
            }
 
            Internals\CallbackSubscriptionTable::delete($row['ID']);
        }
        if ($hasGroup)
        {
            return true;
        }
 
        $callbackSubscriptionResult = Internals\CallbackSubscriptionTable::add([
            'TYPE' => static::TYPE_CODE,
            'GROUP_ID' => $groupId
        ]);
 
        return $callbackSubscriptionResult->isSuccess();
    }
 
    public static function convertField(Field $field): array
    {
        foreach ($item = $field->toArray() as $key => $value)
        {
            if (empty($value))
            {
                unset($item[$key]);
            }
        }
 
        return $item;
    }
 
    public static function convertFields(array $fields): array
    {
        return array_map(
            static function($field)
            {
                return static::convertField($field);
            },
            $fields
        );
    }
 
    public static function getUrlFormList(): string
    {
        return static::URL_FORM_LIST;
    }
 
    public function loadLeads($formId): \Bitrix\Main\Result
    {
        return new \Bitrix\Main\Result();
    }
 
    public static function isSupportAccount(): bool
    {
        return true;
    }
 
    public static function getPrivacyPolicyUrl(): string
    {
        switch ($langId = Context::getCurrent()->getLanguage())
        {
            case 'ua':
            case 'ru':
            case 'kz':
            case 'by':
                return "https://www.bitrix24.{$langId}/about/privacy.php";
            case 'de':
                return "https://www.bitrix24.{$langId}/privacy/";
 
            default:
                return 'https://www.bitrix24.com/privacy/';
        }
    }
 
    protected function registerFormWebHook($adsFormId, array $parameters = []): bool
    {
        return WebHook\Service::create(
            Service::getEngineCode(static::TYPE_CODE),
            $adsFormId
        )->register($parameters);
    }
 
    protected function registerForm($adsFormId)
    {
        return WebHook\Service::registerForm($adsFormId);
    }
 
    public function unregisterForms()
    {
        
    }
 
    public function unregisterForm($adsFormId): bool
    {
        return WebHook\Service::unregisterForm($adsFormId);
    }
 
    protected function removeFormWebHook($adsFormId): bool
    {
        return WebHook\Service::create(
            Service::getEngineCode(static::TYPE_CODE),
            $adsFormId
        )->remove();
    }
 
    public static function isGroupAuthUsed(): bool
    {
        return static::USE_GROUP_AUTH;
    }
 
    protected function getAuthParameters(): array
    {
        return [];
    }
 
    public function getGroupAuthAdapter(): ?Retargeting\AuthAdapter
    {
        if (!self::isGroupAuthUsed())
        {
            return null;
        }
 
        $adapter = Retargeting\AuthAdapter::create(static::TYPE_CODE . '.groups', $this->service);
        $adapter = $adapter->setParameters($this->getAuthParameters());
        $row = Internals\CallbackSubscriptionTable::getRow([
            'filter' => [
                '=TYPE' => static::TYPE_CODE,
            ]
        ]);
 
        if ($row && $row['HAS_AUTH'] !== 'Y' && $adapter->hasAuth())
        {
            Internals\CallbackSubscriptionTable::update($row['ID'], ['HAS_AUTH' => 'Y']);
        }
 
        return $adapter;
    }
}