LikeableRecountCommand::normalizeModelType() - Code Metrics - turahe/laravel-likeable - Measure and Improve Code Quality continuously with Scrutinizer

LikeableRecountCommand::normalizeModelType() A
last analyzed 2021-01-04 12:49 UTC

↳ Parent: LikeableRecountCommand

Complexity

Conditions	4
Paths	5

Size

Total Lines	21
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	12
nc	5
nop	1
dl	0
loc	21
rs	9.8666
c	1
b	0
f	0

<?php

namespace Turahe\Likeable\Console;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
use Illuminate\Contracts\Events\Dispatcher;
use Turahe\Likeable\Contracts\Like as LikeContract;
use Illuminate\Database\Eloquent\Relations\Relation;
use Turahe\Likeable\Exceptions\ModelInvalidException;
use Turahe\Likeable\Contracts\Likeable as LikeableContract;
use Turahe\Likeable\Contracts\LikeCounter as LikeCounterContract;
use Turahe\Likeable\Services\LikeableService as LikeableServiceContract;

class LikeableRecountCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'likeable:recount {model?} {type?}';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Recount likes and dislikes for the models';

    /**
     * Type of likes to be recounted.
     *
     * @var string|null
     */
    protected $likeType;

    /**
     * Likeable service.
     *
     * @var \Turahe\Likeable\Contracts\LikeableService
     */
    protected $service;

    /**
     * Execute the console command.
     *
     * @param \Illuminate\Contracts\Events\Dispatcher $events
     * @return void
     *
     * @throws \Turahe\Likeable\Exceptions\ModelInvalidException
     */
    public function handle(Dispatcher $events)
    public function handle(/** @scrutinizer ignore-unused */ Dispatcher $events)
    {
        $model = $this->argument('model');
        $this->likeType = $this->argument('type');
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        $this->service = app(LikeableServiceContract::class);

        if (empty($model)) {
            $this->recountLikesOfAllModelTypes();
        } else {
            $this->recountLikesOfModelType($model);
            $this->recountLikesOfModelType(/** @scrutinizer ignore-type */ $model);
        }
    }

    /**
     * Recount likes of all model types.
     *
     * @return void
     *
     * @throws \Turahe\Likeable\Exceptions\ModelInvalidException
     */
    protected function recountLikesOfAllModelTypes()
    {
        $likeableTypes = app(LikeContract::class)->groupBy('likeable_type')->get();
        $likeableTypes = app(LikeContract::class)->/** @scrutinizer ignore-call */ groupBy('likeable_type')->get();
        foreach ($likeableTypes as $like) {
            $this->recountLikesOfModelType($like->likeable_type);
        }
    }

    /**
     * Recount likes of model type.
     *
     * @param string $modelType
     * @return void
     *
     * @throws \Turahe\Likeable\Exceptions\ModelInvalidException
     */
    protected function recountLikesOfModelType($modelType)
    {
        $modelType = $this->normalizeModelType($modelType);

        $counters = $this->service->fetchLikesCounters($modelType, $this->likeType);

        $this->service->removeLikeCountersOfType($modelType, $this->likeType);

        DB::table(app(LikeCounterContract::class)->getTable())->insert($counters);
        DB::table(app(LikeCounterContract::class)->/** @scrutinizer ignore-call */ getTable())->insert($counters);

        $this->info('All ['.$modelType.'] records likes has been recounted.');
    }

    /**
     * Normalize likeable model type.
     *
     * @param string $modelType
     * @return string
     *
     * @throws \Turahe\Likeable\Exceptions\ModelInvalidException
     */
    protected function normalizeModelType($modelType)
    {
        $morphMap = Relation::morphMap();

        if (class_exists($modelType)) {
            $model = new $modelType;
            $modelType = $model->getMorphClass();
        } else {
            if (! isset($morphMap[$modelType])) {
                throw new ModelInvalidException("[$modelType] class and morph map are not found.");
            }

            $modelClass = $morphMap[$modelType];
            $model = new $modelClass;
        }

        if (! $model instanceof LikeableContract) {
            throw new ModelInvalidException("[$modelType] not implements Likeable contract.");
        }

        return $modelType;
    }
}


turahe / laravel-likeable

LikeableRecountCommand::normalizeModelType() A last analyzed 2021-01-04 12:49 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

LikeableRecountCommand::normalizeModelType() A
last analyzed 2021-01-04 12:49 UTC