DictionaryCampaign.php

<?php

namespace App\Models\Pivots;

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

/**
 * App\Models\Pivots\DictionaryCampaign
 *
 * @property-read Campaigns $campaign
 * @property-read Dictionary $dictionary
 * @property-read DictionaryCampaignVariable[] $dictionaryCampaignVariables
 * @property-read Variable[] $variables
 * @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 $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
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forExternal()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign forNotExternal()
 * @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 synchronized()
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign notExternalUpdated()
 * @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 whereUpdated($value)
 * @method static \Illuminate\Database\Eloquent\Builder|DictionaryCampaign whereUpdatedAt($value)
 * @method static Builder|DictionaryCampaign whereExternalUploadAt($value)
 */
class DictionaryCampaign extends Pivot
{

    protected $table = 'dictionary_campaigns';

    protected $fillable = [
        'external_id',
        'campaign_id',
        'dictionary_id',
        'name',
        'negative_keywords',
        'excluded_sites',
        'external_upload_at',
        'external_updated_at',
        'updated_self',
        'updated_children',
        'updated',
        'synced',
    ];

    protected $casts = [
        'external_id' => 'int',
        'campaign_id' => 'int',
        'dictionary_id' => 'int',
        'negative_keywords' => 'array',
        'excluded_sites' => 'array',
        'external_upload_at' => 'datetime',
        'external_updated_at' => 'datetime',
        'updated_self' => 'datetime',
        'updated_children' => 'datetime',
        'updated' => 'boolean',
        'synced' => 'boolean',
    ];

    static public function getWithPivot()
    {
        return [
            'name',
            'negative_keywords',
            'excluded_sites',
            'external_upload_at',
            'external_updated_at',
            'updated_self',
            'updated_children',
            'updated',
            'synced',
        ];
    }

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

    /**
     * @param Campaigns|array $campaign
     */
    static public function copyPropertyInCampaign($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 => $campaign->{$property_name}
                ];
            })->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 scopeUpdated(Builder $query, $updated = true)
    {
        return $query->where('updated', $updated);
    }

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

    public function scopeSynchronized(Builder $query)
    {
        return $query->synced()
            ->where(function (Builder $query) {
                $query->updated()->orWhere(function (Builder $query) {
                    $query->updated(false)->notExternalUpdated();
                });
            });
    }

    public function scopeNotExternalUpdated(Builder $query)
    {
        $query->whereNull('external_updated_at');
    }

    public function scopeForUpdatedSelf(Builder $query)
    {
        $query->whereNotNull('updated_self');
    }

    public function scopeForUpdatedChildren(Builder $query)
    {
        $query->whereNotNull('updated_children');
    }

    public function scopeJoinDictionaries(Builder $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();
    }

}