Turahe\Likeable\Console\LikeableRecountCommand

Complexity

Total Complexity

9

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	normalizeModelType()	0	21	4
A	handle()	0	10	2
A	recountLikesOfAllModelTypes()	0	5	2
A	recountLikesOfModelType()	0	11	1

<?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)

The parameter $events is not used and could be removed.

    {
        $model = $this->argument('model');
        $this->likeType = $this->argument('type');

It seems like $this->argument('type') can also be of type string[]. However, the property $likeType is declared as type null|string. Maybe add an additional type check?

        $this->service = app(LikeableServiceContract::class);

        if (empty($model)) {
            $this->recountLikesOfAllModelTypes();
        } else {
            $this->recountLikesOfModelType($model);

It seems like $model can also be of type string[]; however, parameter $modelType of Turahe\Likeable\Console\LikeableRecountCommand::recountLikesOfModelType() does only seem to accept string, maybe add an additional type check?

        }
    }

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

The method groupBy() does not exist on Turahe\Likeable\Contracts\Like. Since it exists in all sub-types, consider adding an abstract or default implementation to Turahe\Likeable\Contracts\Like.

        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);

The method getTable() does not exist on Turahe\Likeable\Contracts\LikeCounter. Since it exists in all sub-types, consider adding an abstract or default implementation to Turahe\Likeable\Contracts\LikeCounter.

        $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;
    }
}