DictionaryCampaign.php

<?php

namespace App\Models\Pivots;

use App\Models\BidModifier;
use App\Models\Campaigns;
use App\Models\Dictionary;
use App\Models\Variable;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\Pivot;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Collection;

/**
 * App\Models\Pivots\DictionaryCampaign
 *
 * @property-read Campaigns $campaign
 * @property-read Dictionary $dictionary
 * @property-read DictionaryCampaignVariable[] $dictionaryCampaignVariables
 * @property-read Variable[] $variables
 * @property-read \Illuminate\Database\Eloquent\Collection|GoalAdGroup[] $groups
 * @property-read \Illuminate\Database\Eloquent\Collection|GoalAdGroup[] $groupsForNotExternalForNotReserveCreate
 * @property-read \Illuminate\Database\Eloquent\Collection|GoalAdGroup[] $groupsForExternalForUpdatedSelf
 * @property-read \Illuminate\Database\Eloquent\Collection|GoalAdGroup[] $groupsForExternalForNeedUpdatedForNotReserveUpdate
 * @mixin \Eloquent
 * @property int $id
 * @property int|null $external_id
 * @property int $campaign_id
 * @property int $dictionary_id
 * @property string|null $name
 * @property array|null $negative_keywords
 * @property array|null $excluded_sites
 * @property bool $enabled
 * @property bool $updated
 * @property bool $synced
 * @property \Illuminate\Support\Carbon|null $external_upload_at
 * @property \Illuminate\Support\Carbon|null $created_atd
 * @property \Illuminate\Support\Carbon|null $updated_at
 * @property-read int|null $dictionary_campaign_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 notDisabled()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign disabled()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forNotExternal()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forNotReserveCreate()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forNotReserveUpdate()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forNotReserveResume()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forNotReserveSuspend()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign needUpdated()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign enabled($value = true)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forUpdated($value = true)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign needSynced()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign notNeedSynced()
 * @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 forUpdatedSelf()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forUpdatedChildren()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign joinDictionaries()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign newModelQuery()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign newQuery()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign query()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereExternalId($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereCampaignId($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereCreatedAt($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereDictionaryId($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereExcludedSites($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereId($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereName($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereNegativeKeywords($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereUpdatedNeed($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereUpdated($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereUpdatedAt($value)
 * @method static Builder|DictionaryCampaign whereExternalUploadAt($value)
 * @property \Illuminate\Support\Carbon|null $external_updated_at
 * @property \Illuminate\Support\Carbon|null $updated_need
 * @property \Illuminate\Support\Carbon|null $updated_self
 * @property \Illuminate\Support\Carbon|null $updated_children
 * @property \Illuminate\Support\Carbon|null $disabled_at
 * @property \Illuminate\Support\Carbon|null $created_at
 * @method static Builder|DictionaryCampaign whereDisabledAt($value)
 * @method static Builder|DictionaryCampaign whereEnabled($value)
 * @method static Builder|DictionaryCampaign whereExternalUpdatedAt($value)
 * @method static Builder|DictionaryCampaign whereSynced($value)
 * @method static Builder|DictionaryCampaign whereUpdatedChildren($value)
 * @method static Builder|DictionaryCampaign whereUpdatedSelf($value)
 * @property-read \Illuminate\Database\Eloquent\Collection|\App\Models\Pivots\GoalKeyword[] $goalKeywords
 * @property-read int|null $goal_keywords_count
 * @property-read \Illuminate\Database\Eloquent\Collection|\App\Models\Pivots\GoalKeywordDelete[] $goalKeywordsDelete
 * @property-read int|null $goal_keywords_delete_count
 */
class DictionaryCampaign extends Pivot
{
    use SoftDeletes;

    protected $table = 'dictionary_campaigns';

    protected $fillable = [
        'external_id',
        'campaign_id',
        'dictionary_id',
        'name',
        'negative_keywords',
        'excluded_sites',
        'external_upload_at',
        'external_updated_at',
        'updated_need',
        'updated_self',
        'updated_children',
        'enabled',
        'updated',
        'synced',
        'disabled_at',
        'deleted_at',
        'synced_need',
        'reserve_create_at',
        'reserve_update_at',
        'reserve_resume_at',
        'reserve_suspend_at',
    ];

    protected $casts = [
        'negative_keywords' => 'array',
        'excluded_sites' => 'array',
        'external_upload_at' => 'datetime',
        'external_updated_at' => 'datetime',
        'updated_need' => 'datetime',
        'updated_self' => 'datetime',
        'updated_children' => 'datetime',
        'enabled' => 'boolean',
        'updated' => 'boolean',
        'synced' => 'boolean',
        'disabled_at' => 'datetime',
        'synced_need' => 'datetime',
        'reserve_create_at' => 'datetime',
        'reserve_update_at' => 'datetime',
        'reserve_resume_at' => 'datetime',
        'reserve_suspend_at' => 'datetime',
    ];

    public $incrementing = true;

    static public function getWithPivot()
    {
        return [
            'id',
            'external_id',
            'name',
            'negative_keywords',
            'excluded_sites',
            'external_upload_at',
            'external_updated_at',
            'updated_need',
            'updated_self',
            'updated_children',
            'enabled',
            'updated',
            'synced',
            'disabled_at',
            'synced_need',
            'reserve_create_at',
            'reserve_update_at',
            'reserve_resume_at',
            'reserve_suspend_at',
        ];
    }

    /**
     * @return Collection
     */
    static public function getPropertiesCopyWithPivot()
    {
        return collect([
            'name',
            'negative_keywords',
            'excluded_sites',
        ]);
    }

    /**
     * @param Campaigns|array $campaign
     *
     * @return array
     */
    static public function copyPropertyFromMain($campaign)
    {
        return self::getPropertiesCopyWithPivot()
            ->transform(function ($property_name) use ($campaign) {
                $value = null;

                if ($campaign instanceof Campaigns) {
                    $value = $campaign->{$property_name};
                } elseif (is_array($campaign) && isset($campaign[$property_name])) {
                    $value = $campaign[$property_name];
                }

                return [
                    $property_name => $value
                ];
            })->flatMap(function ($val) {
                return $val;
            })->all();
    }

    static public function updateOrCreateByMain(Campaigns $campaign, Dictionary $dictionary, $syncedNeed = false)
    {
        $data = [];

        if ($syncedNeed) {
            $data['synced_need'] = Carbon::now();
        }

        $data = array_merge(
            DictionaryCampaign::copyPropertyFromMain($campaign),
            $data
        );

        $dictionaryCampaign = DictionaryCampaign::where('dictionary_id', $dictionary->getKey())
            ->where('campaign_id', $campaign->getKey())
            ->whereNull('deleted_at')
            ->first();

        if ($dictionaryCampaign) {
            if ($dictionaryCampaign->synced) {
                $dictionaryCampaign->update($data);
                return $dictionaryCampaign;
            }
        } else {
            $dictionaryCampaign = DictionaryCampaign::create(
                array_merge(
                    $data,
                    [
                        'dictionary_id' => $dictionary->getKey(),
                        'campaign_id' => $campaign->getKey(),
                    ]
                )
            );
            return $dictionaryCampaign;
        }

        return null;
    }

    public static function boot()
    {
        parent::boot();

        static::deleted(function (DictionaryCampaign $dictionaryCampaign) {

            if (!$dictionaryCampaign->forceDeleting) {
                $dictionaryCampaign->groups()->delete();
                $dictionaryCampaign->goalKeywords()->delete();
            }

        });
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeDisabled($query)
    {
        return $query->whereNotNull('disabled_at');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeNotDisabled($query)
    {
        return $query->whereNull('disabled_at');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForExternal($query)
    {
        return $query->whereNotNull('external_id');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForNotExternal($query)
    {
        return $query->whereNull('external_id');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForNotReserveCreate($query)
    {
        return $query->whereNull('reserve_create_at');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForNotReserveUpdate($query)
    {
        return $query->whereNull('reserve_update_at');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForNotReserveResume($query)
    {
        return $query->whereNull('reserve_resume_at');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForNotReserveSuspend($query)
    {
        return $query->whereNull('reserve_suspend_at');
    }

    /**
     * @param Builder $query
     * @param bool $enabled
     * @return Builder
     */
    public function scopeEnabled($query, $enabled = true)
    {
        return $query->where('enabled', $enabled);
    }

    /**
     * @param Builder $query
     * @param bool $updated
     * @return Builder
     */
    public function scopeForUpdated($query, $updated = true)
    {
        return $query->where('updated', $updated);
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeNeedSynced($query)
    {
        return $query->whereNotNull('synced_need');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeNotNeedSynced($query)
    {
        return $query->whereNull('synced_need');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeNeedUpdated($query)
    {
        return $query->whereNotNull('updated_need');
    }

    /**
     * @param Builder $query
     * @param bool $synced
     * @return Builder
     */
    public function scopeSynced($query, $synced = true)
    {
        return $query->where('synced', $synced);
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeSynchronized($query)
    {
        return $query->synced()->forUpdated();
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForUpdatedSelf($query)
    {
        return $query->whereNotNull('updated_self');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeForUpdatedChildren($query)
    {
        return $query->whereNotNull('updated_children');
    }

    /**
     * @param Builder $query
     * @return Builder
     */
    public function scopeJoinDictionaries($query)
    {
        $dictionary_model = Dictionary::getModel();

        return $query->join($dictionary_model->getTable(), "{$query->getModel()->table()}.dictionary_id", '=', "{$dictionary_model->getTable()}.{$dictionary_model->getKeyName()}");
    }

    public function dictionary()
    {
        return $this->belongsTo(Dictionary::class, 'dictionary_id');
    }

    public function campaign()
    {
        return $this->belongsTo(Campaigns::class, '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();
    }

    public function groups()
    {
        return $this->hasMany(GoalAdGroup::class, 'dictionary_campaign_id');
    }

    public function groupsForNotExternalForNotReserveCreate()
    {
        return $this->groups()->forNotExternal()->forNotReserveCreate();
    }

    public function groupsForExternalForUpdatedSelf()
    {
        return $this->groups()->forExternal()->forUpdatedSelf();
    }

    public function groupsForExternalForNeedUpdatedForNotReserveUpdate()
    {
        return $this->groups()->forExternal()->needUpdated()->forNotReserveUpdate();
    }

    public function goalKeywords()
    {
        return $this->hasMany(GoalKeyword::class, 'dictionary_campaign_id');
    }

    public function goalKeywordsForNotExternal()
    {
        return $this->goalKeywords()->forNotExternal();
    }

    public function goalKeywordsForNeedUpdated()
    {
        return $this->goalKeywords()->needUpdated();
    }

    public function goalKeywordsDelete()
    {
        return $this->hasMany(GoalKeywordDelete::class, 'dictionary_campaign_id');
    }

    public function goalAdvertisements()
    {
        return $this->hasMany(GoalAdvertisement::class, 'dictionary_campaign_id');
    }

    public function goalAdvertisementsForNotExternalForNotReserveCreate()
    {
        return $this->goalAdvertisements()->forNotExternal()->forNotReserveCreate();
    }

    public function goalAdvertisementsForNeedUpdatedForNotReserveUpdate()
    {
        return $this->goalAdvertisements()->needUpdated()->forNotReserveUpdate();
    }

    public function goalBidModifiers()
    {
        return $this->hasMany(GoalBidModifier::class, 'dictionary_campaign_id');
    }

    public function goalBidModifiersForNotExternal()
    {
        return $this->goalAdvertisements()->forNotExternal();
    }

}