#19472 Синхронизация групп с целевыми

app/Console/Commands/AdGroupsAdd.php

+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Tokens;
+use App\Models\Variable;
+use App\Service\API\API;
+use App\Service\Requests\APIRequest;
+use Illuminate\Console\Command;
+use Illuminate\Database\Eloquent\Relations\HasManyThrough;
+
+class AdGroupsAdd extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'adgroups:add';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Добавление не созданных групп с целевого аккаунта';
+
+    /**
+     * Create a new command instance.
+     *
+     * @return void
+     */
+    public function __construct()
+    {
+        parent::__construct();
+    }
+
+    /**
+     * Execute the console command.
+     *
+     * @return int
+     */
+    public function handle()
+    {
+        $tokens = Tokens::whereHas('dictionaryCampaignsEnabledForExternal.groupsForNotExternal')
+            ->with('dictionaryCampaignsEnabledForExternal.groupsForNotExternal')
+            ->where('type', '!=', Tokens::MAIN)
+            ->get();
+
+        foreach ($tokens as $token) {
+            $factory = APIRequest::getInstance(API::YANDEX);
+            $factory->setToken($token);
+
+
+            $factory->getRequest('AdGroup', 'add')
+                ->call([
+                    'goalAdGroups' => $token->dictionaryCampaignsEnabledForExternal->pluck('groupsForNotExternal'),
+                ]);
+        }
+
+        return 0;
+    }
+}

app/Console/Commands/CampaignsAdd.php

@@ -59,7 +59,6 @@ class CampaignsAdd extends Command
             $factory->getRequest('Campaigns', 'add')
             $factory->getRequest('Campaigns', 'add')
                 ->call([
                 ->call([
                     'dictionaryCampaigns' => $token->dictionaryCampaignsEnabledForNotExternal,
                     'dictionaryCampaigns' => $token->dictionaryCampaignsEnabledForNotExternal,
-                    'variables' => Variable::all(),
                 ]);
                 ]);
         }
         }
 
 

app/Console/Commands/CampaignsCheckChange.php

@@ -50,7 +50,7 @@ class CampaignsCheckChange extends Command
                 ->call();
                 ->call();
         }
         }
 
 
-        $tokens = Tokens::has('dictionaryCampaignsForExternal')
+        $tokens = Tokens::has('dictionaryCampaignsEnabledForExternal')
             ->where('type', '!=', Tokens::MAIN)->get();
             ->where('type', '!=', Tokens::MAIN)->get();
 
 
         foreach ($tokens as $token) {
         foreach ($tokens as $token) {

app/Http/Controllers/TokensController.php

@@ -168,10 +168,13 @@ class TokensController extends Controller
 
 
             if ($token_main->campaignsForManaged->count()) {
             if ($token_main->campaignsForManaged->count()) {
                 $dictionary->campaigns()->syncWithoutDetaching(
                 $dictionary->campaigns()->syncWithoutDetaching(
-                    $token_main->campaignsForManaged->keyBy($token_main->campaignsForManaged->first()->getKeyName())->transform(function (Campaigns $campaign) {
-                        return DictionaryCampaign::copyPropertyInCampaign($campaign);
+                    $token_main->campaignsForManaged->keyBy(Campaigns::getModel()->getKeyName())->transform(function (Campaigns $campaign) {
+                        return DictionaryCampaign::copyPropertyFromMain($campaign);
                     })->all()
                     })->all()
                 );
                 );
+                $dictionary->campaigns()->get()->each(function (Campaigns $campaign) {
+                    $campaign->copyGroupInGoalGroup();
+                });
             }
             }
 
 
             DB::commit();
             DB::commit();

app/Models/AdGroup.php

@@ -105,9 +105,31 @@ class AdGroup extends Model
     {
     {
         parent::boot();
         parent::boot();
 
 
-        static::updated(function (AdGroup $adGroup) {
+        static::created(function (AdGroup $ad_group) {
+//            Dictionary::whereNotNull('token_id')->each(function (Dictionary $dictionary) use ($campaign) {
+//                $campaign->dictionaries()->syncWithoutDetaching([
+//                    $dictionary->getKey() => DictionaryCampaign::copyPropertyFromMain($campaign),
+//                ]);
+//            });
+        });
 
 
-            //
+        static::updated(function (AdGroup $ad_group) {
+
+//            if (DictionaryCampaign::getPropertiesCopyWithPivot()->first(function ($property_name) use ($campaign) {
+//                return $campaign->{$property_name} !== $campaign->getOriginal($property_name);
+//            })) {
+//                $campaign->dictionaryCampaigns()->enabled()->synchronized()->update(
+//                    DictionaryCampaign::copyPropertyFromMain($campaign)
+//                );
+//            }
+//
+//            if (self::getPropertiesWatch()->first(function ($property_name) use ($campaign) {
+//                return $campaign->{$property_name} !== $campaign->getOriginal($property_name);
+//            })) {
+//                $campaign->dictionaryCampaigns()->enabled()->synchronized()->forExternal()->update([
+//                    'updated_need' => Carbon::now(),
+//                ]);
+//            }
 
 
         });
         });
     }
     }

app/Models/Campaigns.php

@@ -4,6 +4,7 @@ namespace App\Models;
 
 
 use App\Models\Pivots\DictionaryCampaignVariable;
 use App\Models\Pivots\DictionaryCampaignVariable;
 use App\Models\Pivots\DictionaryCampaign;
 use App\Models\Pivots\DictionaryCampaign;
+use App\Models\Pivots\GoalAdGroup;
 use Carbon\Carbon;
 use Carbon\Carbon;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
@@ -170,11 +171,7 @@ class Campaigns extends Model
 
 
         static::created(function (Campaigns $campaign) {
         static::created(function (Campaigns $campaign) {
             if ($campaign->manage) {
             if ($campaign->manage) {
-                Dictionary::whereNotNull('token_id')->each(function (Dictionary $dictionary) use ($campaign) {
-                    $campaign->dictionaries()->syncWithoutDetaching([
-                        $dictionary->getKey() => DictionaryCampaign::copyPropertyInCampaign($campaign),
-                    ]);
-                });
+                $campaign->copyInGoalCampaign();
             }
             }
         });
         });
 
 
@@ -182,13 +179,9 @@ class Campaigns extends Model
 
 
             if ($campaign->manage !== $campaign->getOriginal('manage')) {
             if ($campaign->manage !== $campaign->getOriginal('manage')) {
                 if ($campaign->manage) {
                 if ($campaign->manage) {
-                    Dictionary::whereNotNull('token_id')->each(function (Dictionary $dictionary) use ($campaign) {
-                        $campaign->dictionaries()->syncWithoutDetaching([
-                            $dictionary->getKey() => DictionaryCampaign::copyPropertyInCampaign($campaign),
-                        ]);
-                    });
+                    $campaign->copyInGoalCampaign();
                 } else {
                 } else {
-                    $campaign->dictionaries()->detach();
+//                    $campaign->dictionaries()->detach();
                 }
                 }
             }
             }
 
 
@@ -196,7 +189,7 @@ class Campaigns extends Model
                 return $campaign->{$property_name} !== $campaign->getOriginal($property_name);
                 return $campaign->{$property_name} !== $campaign->getOriginal($property_name);
             })) {
             })) {
                 $campaign->dictionaryCampaigns()->enabled()->synchronized()->update(
                 $campaign->dictionaryCampaigns()->enabled()->synchronized()->update(
-                    DictionaryCampaign::copyPropertyInCampaign($campaign)
+                    DictionaryCampaign::copyPropertyFromMain($campaign)
                 );
                 );
             }
             }
 
 
@@ -211,6 +204,41 @@ class Campaigns extends Model
         });
         });
     }
     }
 
 
+    private function copyInGoalCampaign()
+    {
+        $campaign = $this;
+
+        Dictionary::whereNotNull('token_id')->get()->each(function (Dictionary $dictionary) use ($campaign) {
+
+            $campaign->dictionaries()->syncWithoutDetaching([
+                $dictionary->getKey() => DictionaryCampaign::copyPropertyFromMain($campaign),
+            ]);
+
+        });
+    }
+
+    public function copyGroupInGoalGroup()
+    {
+        $campaign = $this;
+
+        $campaign->dictionaryCampaigns()->get()->each(function (DictionaryCampaign $dictionaryCampaign) use ($campaign) {
+
+            $campaign->groups()->get()->each(function (AdGroup $adGroup) use ($dictionaryCampaign) {
+
+                $dictionaryCampaign->groups()->create(
+                    array_merge(
+                        GoalAdGroup::copyPropertyFromMain($adGroup),
+                        [
+                            'campaign_external_id' => $dictionaryCampaign->external_id,
+                        ]
+                    )
+                );
+
+            });
+
+        });
+    }
+
     public function getBiddingStrategyAttribute($bidding_strategy)
     public function getBiddingStrategyAttribute($bidding_strategy)
     {
     {
         $bidding_strategy = json_decode($bidding_strategy, true);
         $bidding_strategy = json_decode($bidding_strategy, true);

app/Models/Pivots/DictionaryCampaign.php

@@ -2,9 +2,9 @@
 
 
 namespace App\Models\Pivots;
 namespace App\Models\Pivots;
 
 
+use \App\Models\Pivots\GoalAdGroup;
 use App\Models\Campaigns;
 use App\Models\Campaigns;
 use App\Models\Dictionary;
 use App\Models\Dictionary;
-use App\Models\Limits;
 use App\Models\Variable;
 use App\Models\Variable;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Relations\Pivot;
 use Illuminate\Database\Eloquent\Relations\Pivot;
@@ -17,6 +17,7 @@ use Illuminate\Support\Collection;
  * @property-read Dictionary $dictionary
  * @property-read Dictionary $dictionary
  * @property-read DictionaryCampaignVariable[] $dictionaryCampaignVariables
  * @property-read DictionaryCampaignVariable[] $dictionaryCampaignVariables
  * @property-read Variable[] $variables
  * @property-read Variable[] $variables
+ * @property-read GoalAdGroup[] $groups
  * @mixin \Eloquent
  * @mixin \Eloquent
  * @property int $id
  * @property int $id
  * @property int|null $external_id
  * @property int|null $external_id
@@ -33,6 +34,7 @@ use Illuminate\Support\Collection;
  * @property \Illuminate\Support\Carbon|null $updated_at
  * @property \Illuminate\Support\Carbon|null $updated_at
  * @property-read int|null $dictionary_campaign_variables_count
  * @property-read int|null $dictionary_campaign_variables_count
  * @property-read int|null $variables_count
  * @property-read int|null $variables_count
+ * @property-read int|null $groups_count
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forExternal()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forExternal()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign notDisabled()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign notDisabled()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign disabled()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign disabled()
@@ -42,7 +44,6 @@ use Illuminate\Support\Collection;
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign updated($value = true)
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign updated($value = true)
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign synced($value = true)
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign synced($value = true)
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign synchronized()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign synchronized()
- * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign notExternalUpdated()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forUpdatedSelf()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forUpdatedSelf()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forUpdatedChildren()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forUpdatedChildren()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign joinDictionaries()
  * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign joinDictionaries()
@@ -137,7 +138,7 @@ class DictionaryCampaign extends Pivot
     /**
     /**
      * @param Campaigns|array $campaign
      * @param Campaigns|array $campaign
      */
      */
-    static public function copyPropertyInCampaign($campaign)
+    static public function copyPropertyFromMain($campaign)
     {
     {
         return self::getPropertiesCopyWithPivot()
         return self::getPropertiesCopyWithPivot()
             ->transform(function ($property_name) use ($campaign) {
             ->transform(function ($property_name) use ($campaign) {
@@ -150,7 +151,7 @@ class DictionaryCampaign extends Pivot
                 }
                 }
 
 
                 return [
                 return [
-                    $property_name => $campaign->{$property_name}
+                    $property_name => $value
                 ];
                 ];
             })->flatMap(function ($val) {
             })->flatMap(function ($val) {
                 return $val;
                 return $val;
@@ -202,16 +203,11 @@ class DictionaryCampaign extends Pivot
         return $query->synced()
         return $query->synced()
             ->where(function (Builder $query) {
             ->where(function (Builder $query) {
                 $query->updated()->orWhere(function (Builder $query) {
                 $query->updated()->orWhere(function (Builder $query) {
-                    $query->updated(false)->notExternalUpdated();
+                    $query->updated(false)->forNotExternal();
                 });
                 });
             });
             });
     }
     }
 
 
-    public function scopeNotExternalUpdated(Builder $query)
-    {
-        $query->whereNull('external_updated_at');
-    }
-
     public function scopeForUpdatedSelf(Builder $query)
     public function scopeForUpdatedSelf(Builder $query)
     {
     {
         $query->whereNotNull('updated_self');
         $query->whereNotNull('updated_self');
@@ -252,4 +248,14 @@ class DictionaryCampaign extends Pivot
             ->withTimestamps();
             ->withTimestamps();
     }
     }
 
 
+    public function groups()
+    {
+        return $this->hasMany(GoalAdGroup::class, 'dictionary_campaign_id');
+    }
+
+    public function groupsForNotExternal()
+    {
+        return $this->groups()->forNotExternal();
+    }
+
 }
 }

app/Models/Pivots/GoalAdGroup.php

+<?php
+
+namespace App\Models\Pivots;
+
+use App\Models\AdGroup;
+use App\Models\Campaigns;
+use App\Models\Variable;
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Relations\Pivot;
+use Illuminate\Support\Collection;
+
+class GoalAdGroup extends Pivot
+{
+
+    protected $table = 'goal_ad_groups';
+
+    protected $fillable = [
+        'external_id',
+        'campaign_external_id',
+        'dictionary_campaign_id',
+        'name',
+        'negative_keywords',
+        'external_upload_at',
+        'external_updated_at',
+        'updated_need',
+        'updated_self',
+    ];
+
+    protected $casts = [
+        'dictionary_campaign_id' => 'int',
+        'external_id' => 'int',
+        'campaign_external_id' => 'int',
+        'negative_keywords' => 'array',
+        'external_upload_at' => 'datetime',
+        'external_updated_at' => 'datetime',
+        'updated_need' => 'datetime',
+        'updated_self' => 'datetime',
+    ];
+
+    static public function getWithPivot()
+    {
+        return [
+            'id',
+            'external_id',
+            'campaign_external_id',
+            'dictionary_campaign_id',
+            'name',
+            'negative_keywords',
+            'external_upload_at',
+            'external_updated_at',
+            'updated_self',
+            'updated_need',
+        ];
+    }
+
+    /**
+     * @return Collection
+     */
+    static public function getPropertiesCopyWithPivot()
+    {
+        return collect([
+            'name',
+            'negative_keywords',
+        ]);
+    }
+
+    /**
+     * @param AdGroup|array $ad_group
+     */
+    static public function copyPropertyFromMain($ad_group)
+    {
+        return self::getPropertiesCopyWithPivot()
+            ->transform(function ($property_name) use ($ad_group) {
+                $value = null;
+
+                if ($ad_group instanceof AdGroup) {
+                    $value = $ad_group->{$property_name};
+                } elseif (is_array($ad_group) && isset($ad_group[$property_name])) {
+                    $value = $ad_group[$property_name];
+                }
+
+                return [
+                    $property_name => $value
+                ];
+            })->flatMap(function ($val) {
+                return $val;
+            })->all();
+    }
+
+    public function scopeForExternal(Builder $query)
+    {
+        return $query->whereNotNull('external_id');
+    }
+
+    public function scopeForNotExternal(Builder $query)
+    {
+        return $query->whereNull('external_id');
+    }
+
+    public function scopeNeedUpdated(Builder $query)
+    {
+        return $query->whereNotNull('updated_need');
+    }
+
+    public function scopeForUpdatedSelf(Builder $query)
+    {
+        $query->whereNotNull('updated_self');
+    }
+
+    public function dictionaryCampaign()
+    {
+        return $this->belongsTo(Campaigns::class, 'dictionary_campaign_id');
+    }
+
+    public function dictionaryCampaignVariables()
+    {
+        return $this->hasMany(DictionaryCampaignVariable::class, 'dictionary_campaign_id');
+    }
+
+    public function variables()
+    {
+        return $this->belongsToMany(Variable::class, 'dictionary_campaign_variables', 'dictionary_campaign_id', 'variable_id')
+            ->using(DictionaryCampaignVariable::class)
+            ->withPivot(DictionaryCampaignVariable::getWithPivot())
+            ->withTimestamps();
+    }
+
+}

app/Models/Tokens.php

@@ -178,6 +178,11 @@ class Tokens extends Model
         return $this->dictionaryCampaigns()->forExternal();
         return $this->dictionaryCampaigns()->forExternal();
     }
     }
 
 
+    public function dictionaryCampaignsEnabledForExternal()
+    {
+        return $this->dictionaryCampaignsForExternal()->enabled();
+    }
+
     public function dictionaryCampaignsEnabledForNotExternal()
     public function dictionaryCampaignsEnabledForNotExternal()
     {
     {
         return $this->dictionaryCampaigns()->enabled()->forNotExternal();
         return $this->dictionaryCampaigns()->enabled()->forNotExternal();

app/Models/Variable.php

@@ -36,10 +36,14 @@ class Variable extends Model
         'default_value',
         'default_value',
     ];
     ];
 
 
-    public static function getListVariablesByDictionaryCampaign(DictionaryCampaign $dictionaryCampaign)
+    public static function getListVariablesByDictionaryCampaign(DictionaryCampaign $dictionaryCampaign, $variables = null)
     {
     {
         $variable_list = [];
         $variable_list = [];
 
 
+        if (!$variables) {
+            $variables = Variable::all();
+        }
+
         foreach (Variable::all() as $variable) {
         foreach (Variable::all() as $variable) {
             $dictionaryCampaignVariable = $variable->findValue($dictionaryCampaign->getKey());
             $dictionaryCampaignVariable = $variable->findValue($dictionaryCampaign->getKey());
 
 

app/Service/Requests/Direct/AddAdGroup.php

+<?php
+
+namespace App\Service\Requests\Direct;
+
+use App\Jobs\ProcessCallLimitedAPI;
+use App\Models\Campaigns;
+use App\Models\Pivots\DictionaryCampaign;
+use App\Models\Variable;
+use App\Service\Contract\APIRequest;
+use App\Service\Requests\DirectRequest;
+use App\Service\StrReplaceByVariables;
+use Carbon\Carbon;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Support\Facades\Log;
+
+class AddAdGroup extends DirectRequest
+{
+    CONST MAX_COUNT = 10;
+
+    protected $timestamp;
+    /* @var Collection|DictionaryCampaign[] $dictionaryCampaigns */
+    protected $dictionaryCampaigns;
+    /* @var Collection|Variable[] $dictionaryCampaigns */
+    protected $variables;
+
+    public function call($params = null)
+    {
+        $this->requestPrepare($params);
+        $process = new ProcessCallLimitedAPI($this);
+        dispatch($process)->onQueue('limits');
+    }
+
+    public function getObjectsCount()
+    {
+        return count($this->getParams()['Campaigns']);
+    }
+
+    public function slice($maxObjects): ?APIRequest
+    {
+        $splinter = $this->sliceByKey($maxObjects, 'Campaigns');
+
+        $splinter->putParams([
+            'dictionaryCampaigns' => $this->dictionaryCampaigns->slice($maxObjects)->values(),
+        ]);
+
+        $this->putParams([
+            'dictionaryCampaigns' => $this->dictionaryCampaigns->slice(0, $maxObjects),
+        ]);
+
+        return $splinter;
+    }
+
+    public function handle($response)
+    {
+        try {
+            if (!isset($response['result'])) {
+                Log::debug($response);
+                Log::debug($this->getParams());
+            }
+
+            foreach ($response['result']['AddResults'] as $key => $add_result) {
+                $external_id = $add_result['Id'] ?? '';
+
+                if (!$external_id) {
+                    Log::debug("AddCampaigns, empty Id");
+                    Log::debug($add_result);
+                    Log::debug($this->getParams());
+                    continue;
+                }
+
+                $dictionaryCampaign = $this->dictionaryCampaigns->get($key);
+
+                $dictionaryCampaign->update([
+                    'external_id' => $external_id,
+                    'external_upload_at' => Carbon::now(),
+                ]);
+
+                $dictionaryCampaign->groups()->update([
+                    'campaign_external_id' => $external_id,
+                ]);
+
+            }
+        } catch (\Exception $e) {
+            Log::debug($e);
+        }
+    }
+
+    public function putParams($params)
+    {
+        $this->dictionaryCampaigns = $params['dictionaryCampaigns'];
+    }
+
+    private function requestPrepare($params)
+    {
+        $this->setService('Campaigns');
+        $this->setMethod('add');
+
+        $this->putParams($params);
+
+        $variables = Variable::all();
+
+        $this->setParams([
+            'Campaigns' => $this->dictionaryCampaigns->map(function (DictionaryCampaign $dictionaryCampaign) use ($variables) {
+
+                $list = Variable::getListVariablesByDictionaryCampaign($dictionaryCampaign, $variables);
+
+                $data = [
+                    'Name' => StrReplaceByVariables::getInstance($dictionaryCampaign->name, $list)->get(),
+                    'StartDate' => Carbon::now()->format('Y-m-d'),
+                    'TextCampaign' => [
+                        'BiddingStrategy' => $dictionaryCampaign->campaign->bidding_strategy,
+                    ],
+                ];
+
+                if ($dictionaryCampaign->campaign->priority_goals && count($dictionaryCampaign->campaign->priority_goals)) {
+                    $data['PriorityGoals'] = $dictionaryCampaign->campaign->priority_goals;
+                }
+
+                if ($dictionaryCampaign->campaign->daily_budget && count($dictionaryCampaign->campaign->daily_budget)) {
+                    $data['DailyBudget'] = $dictionaryCampaign->campaign->daily_budget;
+                }
+
+                if ($dictionaryCampaign->negative_keywords && count($dictionaryCampaign->negative_keywords)) {
+                    $data['NegativeKeywords'] = [
+                        'Items' => array_map(function ($value) use ($list) {
+                            return StrReplaceByVariables::getInstance($value, $list)->get();
+                        }, $dictionaryCampaign->negative_keywords),
+                    ];
+                }
+
+                if ($dictionaryCampaign->campaign->blocked_ips && count($dictionaryCampaign->campaign->blocked_ips)) {
+                    $data['BlockedIps'] = [
+                        'Items' => $dictionaryCampaign->campaign->blocked_ips,
+                    ];
+                }
+
+                if ($dictionaryCampaign->excluded_sites && count($dictionaryCampaign->excluded_sites)) {
+                    $data['ExcludedSites'] = [
+                        'Items' => array_map(function ($value) use ($list) {
+                            return StrReplaceByVariables::getInstance($value, $list)->get();
+                        }, $dictionaryCampaign->excluded_sites),
+                    ];
+                }
+
+                if ($dictionaryCampaign->campaign->relevant_keywords) {
+                    $data['TextCampaign']['RelevantKeywords'] = $dictionaryCampaign->campaign->relevant_keywords;
+                }
+
+                if ($dictionaryCampaign->campaign->attribution_model) {
+                    $data['TextCampaign']['AttributionModel'] = $dictionaryCampaign->campaign->attribution_model;
+                }
+
+                if ($dictionaryCampaign->campaign->settings && count($dictionaryCampaign->campaign->settings)) {
+
+                    $settingsAllow = Campaigns::getSettingOptionsAllow();
+
+                    $settings = [];
+
+                    foreach ($dictionaryCampaign->campaign->settings as $setting) {
+                        if (isset($setting['Option']) && in_array($setting['Option'], $settingsAllow)) {
+                            $settings[] = $setting;
+                        }
+                    }
+
+                    if (count($settings)) {
+                        $data['TextCampaign']['Settings'] = $settings;
+                    }
+
+                }
+
+                if ($dictionaryCampaign->campaign->counter_ids && count($dictionaryCampaign->campaign->counter_ids)) {
+                    $data['TextCampaign']['CounterIds'] = [
+                        'Items' => $dictionaryCampaign->campaign->counter_ids,
+                    ];
+                }
+
+                return $data;
+            })->all(),
+        ]);
+    }
+
+}

app/Service/Requests/Direct/AddCampaigns.php

@@ -44,12 +44,10 @@ class AddCampaigns extends DirectRequest
 
 
         $splinter->putParams([
         $splinter->putParams([
             'dictionaryCampaigns' => $this->dictionaryCampaigns->slice($maxObjects)->values(),
             'dictionaryCampaigns' => $this->dictionaryCampaigns->slice($maxObjects)->values(),
-            'variables' => $this->variables,
         ]);
         ]);
 
 
         $this->putParams([
         $this->putParams([
             'dictionaryCampaigns' => $this->dictionaryCampaigns->slice(0, $maxObjects),
             'dictionaryCampaigns' => $this->dictionaryCampaigns->slice(0, $maxObjects),
-            'variables' => $this->variables,
         ]);
         ]);
 
 
         return $splinter;
         return $splinter;
@@ -73,11 +71,17 @@ class AddCampaigns extends DirectRequest
                     continue;
                     continue;
                 }
                 }
 
 
-                $this->dictionaryCampaigns->get($key)->update([
+                $dictionaryCampaign = $this->dictionaryCampaigns->get($key);
+
+                $dictionaryCampaign->update([
                     'external_id' => $external_id,
                     'external_id' => $external_id,
                     'external_upload_at' => Carbon::now(),
                     'external_upload_at' => Carbon::now(),
                 ]);
                 ]);
 
 
+                $dictionaryCampaign->groups()->update([
+                    'campaign_external_id' => $external_id,
+                ]);
+
             }
             }
         } catch (\Exception $e) {
         } catch (\Exception $e) {
             Log::debug($e);
             Log::debug($e);
@@ -87,7 +91,6 @@ class AddCampaigns extends DirectRequest
     public function putParams($params)
     public function putParams($params)
     {
     {
         $this->dictionaryCampaigns = $params['dictionaryCampaigns'];
         $this->dictionaryCampaigns = $params['dictionaryCampaigns'];
-        $this->variables = $params['variables'];
     }
     }
 
 
     private function requestPrepare($params)
     private function requestPrepare($params)
@@ -97,10 +100,12 @@ class AddCampaigns extends DirectRequest
 
 
         $this->putParams($params);
         $this->putParams($params);
 
 
+        $variables = Variable::all();
+
         $this->setParams([
         $this->setParams([
-            'Campaigns' => $this->dictionaryCampaigns->map(function (DictionaryCampaign $dictionaryCampaign) {
+            'Campaigns' => $this->dictionaryCampaigns->map(function (DictionaryCampaign $dictionaryCampaign) use ($variables) {
 
 
-                $list = Variable::getListVariablesByDictionaryCampaign($dictionaryCampaign);
+                $list = Variable::getListVariablesByDictionaryCampaign($dictionaryCampaign, $variables);
 
 
                 $data = [
                 $data = [
                     'Name' => StrReplaceByVariables::getInstance($dictionaryCampaign->name, $list)->get(),
                     'Name' => StrReplaceByVariables::getInstance($dictionaryCampaign->name, $list)->get(),

app/Service/Requests/Direct/GetAdGroups.php

@@ -5,6 +5,7 @@ namespace App\Service\Requests\Direct;
 use App\Jobs\ProcessCallLimitedAPI;
 use App\Jobs\ProcessCallLimitedAPI;
 use App\Models\AdGroup;
 use App\Models\AdGroup;
 use App\Models\Campaigns;
 use App\Models\Campaigns;
+use App\Models\Pivots\DictionaryCampaign;
 use App\Service\Requests\DirectRequest;
 use App\Service\Requests\DirectRequest;
 use Carbon\Carbon;
 use Carbon\Carbon;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\DB;
@@ -24,12 +25,9 @@ class GetAdGroups extends DirectRequest
     {
     {
         DB::beginTransaction();
         DB::beginTransaction();
         try {
         try {
-            $data = [];
-
             $external_ids = [];
             $external_ids = [];
 
 
             if (!isset($response['result']['AdGroups'])) {
             if (!isset($response['result']['AdGroups'])) {
-                Log::debug($response);
                 return;
                 return;
             }
             }
 
 
@@ -58,42 +56,44 @@ class GetAdGroups extends DirectRequest
                 $campaign->groups_loaded_at = Carbon::now();
                 $campaign->groups_loaded_at = Carbon::now();
                 $campaign->save();
                 $campaign->save();
 
 
-                $data[] = [
+                $external_id = $ad_group['Id'];
+
+                $data = [
                     'campaign_id' => $campaign->getKey(),
                     'campaign_id' => $campaign->getKey(),
-                    'external_id' => $ad_group['Id'],
+                    'external_id' => $external_id,
                     'campaign_external_id' => $ad_group['CampaignId'],
                     'campaign_external_id' => $ad_group['CampaignId'],
                     'name' => $ad_group['Name'],
                     'name' => $ad_group['Name'],
                     'status' => $ad_group['Status'],
                     'status' => $ad_group['Status'],
                     'type' => $ad_group['Type'],
                     'type' => $ad_group['Type'],
                     'sub_type' => $ad_group['Subtype'],
                     'sub_type' => $ad_group['Subtype'],
                     'serving_status' => $ad_group['ServingStatus'],
                     'serving_status' => $ad_group['ServingStatus'],
-                    'restricted_region_ids' => $ad_group['RestrictedRegionIds'] ? json_encode($ad_group['RestrictedRegionIds']) : null,
-                    'region_ids' => $ad_group['RegionIds'] ? json_encode($ad_group['RegionIds']) : null,
-                    'negative_keywords' => $ad_group['NegativeKeywords'] ? json_encode($ad_group['NegativeKeywords']) : null,
-                    'negative_keyword_shared_set_ids' => $ad_group['NegativeKeywordSharedSetIds'] ? json_encode($ad_group['NegativeKeywordSharedSetIds']) : null,
+                    'restricted_region_ids' => $ad_group['RestrictedRegionIds'],
+                    'region_ids' => $ad_group['RegionIds'],
+                    'negative_keywords' => $ad_group['NegativeKeywords'],
+                    'negative_keyword_shared_set_ids' => $ad_group['NegativeKeywordSharedSetIds'],
                     'tracking_params' => $ad_group['TrackingParams'],
                     'tracking_params' => $ad_group['TrackingParams'],
                     'updated_self' => null,
                     'updated_self' => null,
                 ];
                 ];
+
+
+                if ($this->getToken()->isMain()) {
+                    AdGroup::updateOrCreate([
+                        'external_id' => $external_id
+                    ], $data);
+                } else {
+                    $dictionaryCampaign = DictionaryCampaign::synchronized()
+                        ->find($external_id);
+
+                    if (!$dictionaryCampaign)
+                        continue;
+
+                    $dictionaryCampaign->update(
+                        $dictionaryCampaign::copyPropertyFromMain($campaign_data)
+                    );
+                }
+
             }
             }
 
 
-            AdGroup::upsert($data, [
-                'external_id'
-            ], [
-                'campaign_id',
-                'external_id',
-                'campaign_external_id',
-                'name',
-                'status',
-                'type',
-                'sub_type',
-                'serving_status',
-                'restricted_region_ids',
-                'region_ids',
-                'negative_keywords',
-                'negative_keyword_shared_set_ids',
-                'tracking_params',
-                'updated_self',
-            ]);
             DB::commit();
             DB::commit();
         } catch (\Exception $e) {
         } catch (\Exception $e) {
             DB::rollBack();
             DB::rollBack();

app/Service/Requests/Direct/GetCampaigns.php

@@ -31,6 +31,10 @@ class GetCampaigns extends DirectRequest
     public function handle($response)
     public function handle($response)
     {
     {
         try {
         try {
+            if (!isset($response['result']['Campaigns'])) {
+                return;
+            }
+
             foreach ($response['result']['Campaigns'] as $campaign_data) {
             foreach ($response['result']['Campaigns'] as $campaign_data) {
 
 
                 $external_id = $campaign_data['Id'];
                 $external_id = $campaign_data['Id'];
@@ -65,7 +69,7 @@ class GetCampaigns extends DirectRequest
                         continue;
                         continue;
 
 
                     $dictionaryCampaign->update(
                     $dictionaryCampaign->update(
-                        $dictionaryCampaign::copyPropertyInCampaign($campaign_data)
+                        $dictionaryCampaign::copyPropertyFromMain($campaign_data)
                     );
                     );
                 }
                 }
 
 

app/Service/Requests/Direct/UpdateCampaigns.php

@@ -66,10 +66,12 @@ class UpdateCampaigns extends DirectRequest
         $this->setService('Campaigns');
         $this->setService('Campaigns');
         $this->setMethod('update');
         $this->setMethod('update');
 
 
+        $variables = Variable::all();
+
         $this->setParams([
         $this->setParams([
-            'Campaigns' => $params['dictionaryCampaigns']->map(function (DictionaryCampaign $dictionaryCampaign) {
+            'Campaigns' => $params['dictionaryCampaigns']->map(function (DictionaryCampaign $dictionaryCampaign) use ($variables) {
 
 
-                $list = Variable::getListVariablesByDictionaryCampaign($dictionaryCampaign);
+                $list = Variable::getListVariablesByDictionaryCampaign($dictionaryCampaign, $variables);
 
 
                 $data = [
                 $data = [
                     'Id' => $dictionaryCampaign->external_id,
                     'Id' => $dictionaryCampaign->external_id,

database/migrations/2021_06_02_10638_create_goal_ad_groups_table.php

+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+class CreateGoalAdGroupsTable extends Migration
+{
+    /**
+     * Run the migrations.
+     *
+     * @return void
+     */
+    public function up()
+    {
+        Schema::create('goal_ad_groups', function (Blueprint $table) {
+            $table->id();
+            $table->bigInteger('external_id')->nullable();
+            $table->bigInteger('campaign_external_id')->nullable();
+            $table->bigInteger('dictionary_campaign_id')->unsigned();
+            $table->string('name', 255)->nullable();
+            $table->text('negative_keywords')->nullable();
+            $table->timestamp('external_upload_at')->nullable();
+            $table->timestamp('external_updated_at')->nullable();
+            $table->timestamp('updated_need')->nullable();
+            $table->timestamp('updated_self')->nullable();
+            $table->timestamps();
+
+
+            $table->foreign('dictionary_campaign_id')->references('id')->on('dictionary_campaigns')
+                ->cascadeOnDelete();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     *
+     * @return void
+     */
+    public function down()
+    {
+        Schema::dropIfExists('dictionary_campaigns');
+    }
+}

tests/Unit/ProcessCallSliceTest.php

@@ -70,7 +70,7 @@ class ProcessCallSliceTest extends TestCase
 
 
         $this->campaign->dictionaries()->syncWithoutDetaching(
         $this->campaign->dictionaries()->syncWithoutDetaching(
             $this->dictionaries->keyBy(Campaigns::getModel()->getKeyName())->transform(function (Dictionary $dictionary) {
             $this->dictionaries->keyBy(Campaigns::getModel()->getKeyName())->transform(function (Dictionary $dictionary) {
-                return DictionaryCampaign::copyPropertyInCampaign($this->campaign);
+                return DictionaryCampaign::copyPropertyFromMain($this->campaign);
             })->all()
             })->all()
         );
         );
 
 

tests/Unit/ReplaceByVariablesTest.php

@@ -61,7 +61,7 @@ class ReplaceByVariablesTest extends TestCase
 
 
         $this->dictionary->campaigns()->syncWithoutDetaching(
         $this->dictionary->campaigns()->syncWithoutDetaching(
             $this->token_main->campaignsForManaged->keyBy($this->token_main->campaignsForManaged->first()->getKeyName())->transform(function (Campaigns $campaign) {
             $this->token_main->campaignsForManaged->keyBy($this->token_main->campaignsForManaged->first()->getKeyName())->transform(function (Campaigns $campaign) {
-                return DictionaryCampaign::copyPropertyInCampaign($campaign);
+                return DictionaryCampaign::copyPropertyFromMain($campaign);
             })->all()
             })->all()
         );
         );