ReliqArts\Scavenger\Model\Scrap

Complexity

Total Complexity

15

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getRelated()	0	10	4
A	getTable()	0	3	1
A	relatedModelUsesSoftDeletes()	0	3	1
B	convert()	0	35	9

<?php

declare(strict_types=1);

namespace ReliqArts\Scavenger\Model;

use Illuminate\Database\Eloquent\Model as EloquentModel;
use Illuminate\Support\Facades\Schema;
use JsonException;
use ReliqArts\Scavenger\Service\ConfigProvider;

/**
 * Scavenger Scrap.
 *
 * @property string      $hash
 * @property string      $model
 * @property string      $source
 * @property bool|string $data
 * @property string      $title
 * @property mixed       $related
 *
 * @method static firstOrCreate(array $array, array $array1 = [])
 * @method static firstOrNew(array $array, array $array1 = [])
 */
class Scrap extends EloquentModel
{
    private const SOFT_DELETES_TRAIT = 'Illuminate\Database\Eloquent\SoftDeletes';

    /**
     * @var array
     */
    protected $guarded = [];

    /**
     * Get the scraps table.
     */
    public function getTable(): string
    {
        return ConfigProvider::getScrapsTable();
    }

    /**
     * Convert scrap to target model.
     *
     * @param bool $convertDuplicates     whether to force conversion even if model already exists
     * @param bool $storeRelatedReference Whether to update relation field on scrap (self)
     *                                    N.B. if reference is stored the scrap will be saved.
     *
     * @throws JsonException
     */
    public function convert(bool $convertDuplicates = false, bool $storeRelatedReference = false): ?EloquentModel
    {
        $targetObject = null;
        $convert = true;

        if (!empty($this->model)) {
            $existingRelated = $this->getRelated();

            if ($existingRelated !== null && !$convertDuplicates) {
                return $existingRelated;
            }

            if ($convert) {

The condition $convert is always true.

                /** @var EloquentModel $targetObject */
                $targetObject = new $this->model();
                $targetTable = $targetObject->getTable();

                // Fill model data with scrap data if attributes exist
                foreach (json_decode($this->data, true, 512, JSON_THROW_ON_ERROR) as $attr => $val) {
                    if (!ConfigProvider::isSpecialKey($attr) && Schema::hasColumn($targetTable, $attr)) {
                        $targetObject->{$attr} = $val;
                    }
                }

                // save related model
                $targetObject->save();

                if ($storeRelatedReference) {
                    $this->related = $targetObject->getKey();
                    $this->save();
                }
            }
        }

        return $targetObject;
    }

    /**
     * Convert scrap to target model.
     *
     * @noinspection PhpUndefinedMethodInspection
     */
    public function getRelated(): ?EloquentModel
    {
        if ($this->model && $this->related) {
            // find relation
            return $this->relatedModelUsesSoftDeletes()
                ? $this->model::withTrashed()->find($this->related)
                : $this->model::find($this->related);
        }

        return null;
    }

    /**
     * Whether related model uses eloquent's SoftDeletes trait.
     *
     * @see \Illuminate\Database\Eloquent\SoftDeletes
     */
    public function relatedModelUsesSoftDeletes(): bool
    {
        return in_array(self::SOFT_DELETES_TRAIT, class_uses($this->model, true), true);
    }
}