App\Console\Commands\FindSizeMismatchedReleases

Complexity

Total Complexity

16

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	outputReleaseIdsAsCsv()	0	5	1
C	handle()	0	87	11
A	stripDomainFromString()	0	3	1
A	attemptRename()	0	21	3

<?php

namespace App\Console\Commands;

use App\Models\Release;
use Blacklight\NameFixer;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;

class FindSizeMismatchedReleases extends Command
{
    protected $signature = 'nntmux:find-size-mismatches {--threshold=20} {--limit=100} {--season-pack} {--direction=any} {--rename}';

    protected $description = 'Find releases where size differs significantly from release_files total. Use --direction=bigger|smaller|any';

    public function handle()
    {
        $threshold = $this->option('threshold'); // Percentage difference threshold
        $limit = $this->option('limit');
        $checkSeasonPack = $this->option('season-pack');
        $direction = $this->option('direction');
        $shouldRename = $this->option('rename');
        $nameFixer = new NameFixer;

        $query = Release::query()
            ->select([
                'releases.id',
                'releases.searchname',
                'releases.name',
                'releases.groups_id',
                'releases.categories_id',
                DB::raw('releases.size / POW(1024, 3) as release_size'),
                DB::raw('SUM(release_files.size) / POW(1024, 3) as files_total_size'),
                DB::raw('(releases.size - SUM(release_files.size)) / POW(1024, 3) as size_diff'),
                DB::raw('((releases.size - SUM(release_files.size)) / releases.size * 100) as diff_percent'),
            ])
            ->join('release_files', 'releases.id', '=', 'release_files.releases_id')
            ->where('releases.searchname', 'REGEXP', 'S[0-9]{1,3}E[0-9]{1,3}')
            ->groupBy('releases.id');

        // Apply direction filter
        if ($direction === 'bigger') {
            $query->having('size_diff', '>', 0)
                ->having('diff_percent', '>', $threshold);
        } elseif ($direction === 'smaller') {
            $query->having('size_diff', '<', 0)
                ->having('diff_percent', '<', -$threshold);
        } else {
            $query->having(DB::raw('ABS(diff_percent)'), '>', $threshold);
        }

        // Order by ID if renaming, otherwise by diff_percent
        $query->orderBy($shouldRename ? 'releases.id' : 'diff_percent', $shouldRename ? 'asc' : 'desc');

$shouldRename ? 'releases.id' : 'diff_percent' of type string is incompatible with the type Closure|Illuminate\Database\Eloquent\Builder|Illuminate\Database\Query\Builder expected by parameter $column of Illuminate\Database\Query\Builder::orderBy().

        if ($limit > 0) {
            $query->limit($limit);
        }

        $mismatches = $query->get();

        if ($checkSeasonPack) {
            $mismatches = $mismatches->filter(function ($release) use ($nameFixer) {
                return $nameFixer->isSeasonPack($release->name);

The method isSeasonPack() does not exist on Blacklight\NameFixer.

            });
        }

        if ($mismatches->isEmpty()) {
            $this->info('No releases found with size mismatches above '.$threshold.'%'
                .($checkSeasonPack ? ' that are season packs' : ''));

            return;
        }

        if ($shouldRename) {
            $this->info("\nAttempting to rename ".$mismatches->count()." releases...\n");

            foreach ($mismatches as $release) {
                $this->attemptRename($release, $nameFixer);
            }

            $this->outputReleaseIdsAsCsv($mismatches);

            return;
        }

        // Regular table output for non-rename mode
        $headers = ['Release ID', 'Searchname', 'Release Size', 'Files Total', 'Difference', 'Diff %'];
        $rows = $mismatches->map(function ($release) {
            return [
                $release->id,
                $release->searchname,
                number_format($release->release_size, 2).' GiB',
                number_format($release->files_total_size, 2).' GiB',
                number_format($release->size_diff, 2).' GiB',
                number_format($release->diff_percent, 2).'%',
            ];
        });

        $this->table($headers, $rows);
        $this->info("\nFound ".$mismatches->count().' releases with size mismatches above '.$threshold.'%');

        $this->outputReleaseIdsAsCsv($mismatches);
    }

    private function attemptRename(Release $release, NameFixer $nameFixer): ?string
    {
        if (preg_match(NameFixer::PREDB_REGEX, $this->stripDomainFromString($release->name), $matches)) {

The property name does not seem to exist on App\Models\Release. Are you sure there is no database migration missing?

            $newName = $matches[1];
            if ($newName) {
                $nameFixer->updateRelease(
                    release: $release,
                    name: $newName,
                    method: 'size-mismatch / season pack',
                    echo: true,
                    type: '',
                    nameStatus: 1,
                    show: '1',
                    preId: 0
                );

                return $newName;
            }
        }

        return null;
    }

    private function outputReleaseIdsAsCsv($mismatches): void
    {
        $releaseIds = $mismatches->pluck('id')->join(',');
        $this->line("\nRelease IDs in CSV format:");
        $this->line($releaseIds);
    }

    private function stripDomainFromString(string $str): string
    {
        return preg_replace("/www\.[^\s]+\.[a-z]{2,4}/i", '', $str);
    }
}