GetKeywords.php

<?php

namespace App\Service\Requests\Direct;

use App\Jobs\ProcessCallLimitedAPI;
use App\Models\AdGroup;
use App\Models\Keyword;
use App\Service\Contract\APIRequest;
use App\Service\Requests\DirectRequest;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class GetKeywords extends DirectRequest
{
    protected $max_count = -1;
    protected $max_count_CampaignIds = 10;
    protected $max_count_AdGroupIds = 1000;
    protected $max_count_Ids = 10000;

    function call($params = null)
    {
        $this->requestPrepare($params);
        $process = new ProcessCallLimitedAPI($this);
        dispatch($process)->onQueue('limits');
    }

    public function getObjectsCount()
    {
        $params = $this->getParams();
        if (isset($params['SelectionCriteria']['Ids'])) {
            return count($params['SelectionCriteria']['Ids']);
        }
        return parent::getObjectsCount();
    }

    public function slice($maxObjects): ?APIRequest
    {
        $params = $this->getParams();

        if (isset($params['SelectionCriteria']['Ids'])) {
            return $this->sliceByKey($maxObjects, ['SelectionCriteria', 'Ids']);
        }

        return null;
    }

    function handle($response)
    {

        $connection = config('database.default');

        $external_ids = [];

        if (!$this->getToken()->isMain()) {
            return;//добавлять фразы будем только по основному. По цеелвым будем наоборот выгружать.
        }

        if (!isset($response['result']['Keywords'])) {
            return;
        }

        foreach ($response['result']['Keywords'] as $keyword) {
            $adGroupId = (string)$keyword['AdGroupId'];

            if (isset($external_ids[$adGroupId])) {
                continue;
            }
            $external_ids[$adGroupId] = true;
        }

        if (!count($external_ids)) {
            return;
        }

        if ($this->getToken()->isMain()) {
            $ad_groups = AdGroup::whereIn('external_id', array_keys($external_ids))
                ->get()
                ->keyBy('external_id');
        }

//            $ids = [];
//            $campaign_ids_synced_need = [];
        $insertData = [];

        $now = Carbon::now();
        $cnt = 0;
        $items = [];
        foreach ($response['result']['Keywords'] as $keyword) {

            $ad_group = $ad_groups->get((string)$keyword['AdGroupId']);

            if (!$ad_group) {
                continue;
            }

            $external_id = (string)$keyword['Id'];

            $data = [
                'external_id' => $external_id,
                'campaign_external_id' => $ad_group->campaign_external_id,
                'ad_group_external_id' => $ad_group->external_id,
                'ad_group_id' => $ad_group->getKey(),
                'campaign_id' => $ad_group->campaign_id,
                'keyword' => $keyword['Keyword'],
                'user_param_1' => $keyword['UserParam1'] ?? null,
                'user_param_2' => $keyword['UserParam2'] ?? null,
                'bid' => $keyword['Bid'],
                'context_bid' => $keyword['ContextBid'],
                'strategy_priority' => $keyword['StrategyPriority'] ?? null,
                'state' => $keyword['State'],
                'status' => $keyword['Status'],
                'serving_status' => $keyword['ServingStatus'],
                'updated_at' => $now,
                'deleted_at' => null //не забыть убрать признак удаления, если вдруг опять пришла удаленная ранее фраза
            ];

            $keyword_data = Keyword::where('external_id', $external_id)->withTrashed()->first();
            if ($keyword_data){
                if (!$keyword_data->equals($data)){
                    unset($data['external_id']);
                    //если данные изменились, то надо обновить и в кеше и пометить на то что надо их выгрузить
                    $keyword_data->update($data);
                    $keyword_data->goalKeywords()->update(['updated_need' => $now]);
                }else{
                    $items[] = $external_id;
                }
            } else{
                //новый фразы
                $insertData[$external_id] = $data;
            }

        }

        Keyword::whereIn('external_id', $items)->update([
            'updated_at'    =>  $now
        ]);

        foreach (array_chunk($insertData, 1000) as $data) {
            $items = [];
            foreach ($data as $item){
                $items[] = $item['external_id'];
            }
            Keyword::insertOrIgnore($data);
            Keyword::whereIn('external_id', $items)->update([
                'updated_at' => $now
            ]);
        }

        $now = $connection=='sqlite'? DB::raw("strftime('%Y-%m-%d %H:%M:%S', datetime('now'))") : DB::raw('now()');
        //удаление будет толко когда получаем изменения по группам, иначе это либо загрузка все фраз либо как то избранных
        if  ( !empty($this->getParams()['SelectionCriteria']['AdGroupIds']) &&
            !isset($response['result']['LimitedBy']) ){
            $ag_groups = $this->getParams()['SelectionCriteria']['AdGroupIds'];
            //последний блок с данными, можно удалять те, что так и не получили
            //Выбираем все те фразы, которые обновлены позже чем группа.
            //это означает что этой фразы не было в результатах и в БД она по этой причине не обновилась
            //надо такие пометить на удаление
            //при удалении для всех таких надо будет удалить фразы из целевых и потом удалить их сами
            if ($connection=='sqlite'){
                $sql = "UPDATE keywords
                    SET deleted_at = {$now->getValue()}
                    WHERE updated_at<=(SELECT ag.keywords_loaded_at FROM ad_groups ag WHERE keywords.ad_group_id=ag.id)
                        AND deleted_at is null
                        AND ad_group_external_id in (" . implode(", ", $ag_groups) . ")";
            } else{
                $sql = "UPDATE keywords k
                            INNER JOIN ad_groups ag ON k.ad_group_id=ag.id
                    SET k.deleted_at = {$now->getValue()}
                    WHERE  ag.keywords_loaded_at IS NOT NULL
                        AND k.updated_at<=ag.keywords_loaded_at
                        AND k.deleted_at is null
                        AND ag.external_id in (" . implode(", ", $ag_groups) . ")";
            }

            DB::update($sql);
            AdGroup::whereIn('external_id', $ag_groups)->update(['keywords_loaded_at'   =>  Carbon::now()]);
        }
    }

    private function requestPrepare($filter)
    {
        $this->setService('Keywords');
        $this->setMethod('get');
        $params = [
            "FieldNames" => [
                "Id", "Keyword", "AdGroupId", "CampaignId",
                "UserParam1", "UserParam2", "Bid",
                "ContextBid", "State", "Status", "ServingStatus",
            ],
        ];
        if (isset($filter['CampaignIds'])) {
            $params['SelectionCriteria'] = [
                'CampaignIds' => $filter['CampaignIds'],
            ];
        }
        if (isset($filter['AdGroupIds'])) {
            $params['SelectionCriteria'] = [
                'AdGroupIds' => $filter['AdGroupIds'],
            ];
        }
        if (isset($filter['Ids'])) {
            $this->max_count = $this->max_count_Ids;
            $params['SelectionCriteria'] = [
                'Ids' => $filter['Ids'],
            ];
        }
        $this->setParams($params);
    }
}