diff --git a/app/Console/Commands/ProducersDedupe.php b/app/Console/Commands/ProducersDedupe.php index b9bebca..02b9244 100644 --- a/app/Console/Commands/ProducersDedupe.php +++ b/app/Console/Commands/ProducersDedupe.php @@ -100,6 +100,10 @@ public function handle(ProducerDeduplicator $deduplicator): int foreach ($report['totals'] as $table => $count) { $this->line(' ' . str_pad($table, 24) . number_format($count) . ' sor átírva'); } + $this->line(' ' . str_pad('alias', 24) . count($report['restore']['created_alias_ids'] ?? []) . ' létrehozva'); + foreach ($report['alias_warnings'] ?? [] as $warning) { + $this->warn(' ! alias kihagyva: ' . $warning); + } $this->line(' Jelentés: ' . $reportPath); $this->newLine(); $this->comment('Visszagörgetés: php artisan producers:dedupe --rollback="' . $reportPath . '"'); diff --git a/app/Services/ProducerDeduplicator.php b/app/Services/ProducerDeduplicator.php index bc5c22d..1db0f8f 100644 --- a/app/Services/ProducerDeduplicator.php +++ b/app/Services/ProducerDeduplicator.php @@ -3,8 +3,11 @@ namespace App\Services; use App\Enums\DbStatusFieldEnum; +use App\Models\ProducerAlias; use App\Support\NameNormalizer; +use App\Support\ProducerAliasResolver; use Illuminate\Support\Facades\DB; +use RuntimeException; /** * Duplikált gyártó törzsadat felderítése és összevonása. @@ -43,6 +46,8 @@ class ProducerDeduplicator public const DIFF_MIXED = 'vegyes'; + public function __construct(private ProducerAliasResolver $aliasResolver = new ProducerAliasResolver) {} + /** * Duplikált névcsoportok, csoportonként a tagokkal és a hivatkozás-darabszámokkal. * A tagok rendezettek: az első a javasolt megtartandó (legtöbb termék). @@ -516,6 +521,7 @@ public function apply(array $merges): array 'merges' => [], 'restore' => [], 'totals' => array_fill_keys(array_keys(self::REFERENCING_TABLES), 0), + 'alias_warnings' => [], ]; // producer_id leképezés: honnan => hova @@ -552,6 +558,18 @@ public function apply(array $merges): array $report['totals'][$table] = $this->remap($table, $column, $map); } + $report['restore']['created_alias_ids'] = []; + + // 2b. Ha egy vesztes gyártóhoz már volt alias (mert korábban ő volt egy MÁSIK + // összevonás keepere), az árva maradna: a lookupMap csak aktív gyártóhoz + // tartozó aliast ad vissza. Átpontozzuk az új keeperre. + $existingAliases = ProducerAlias::whereIn('producer_id', array_keys($map))->get(['id', 'producer_id']); + $report['restore']['repointed_aliases'] = $existingAliases->pluck('producer_id', 'id')->toArray(); + + foreach ($existingAliases->groupBy('producer_id') as $fromId => $aliases) { + ProducerAlias::whereIn('id', $aliases->pluck('id'))->update(['producer_id' => $map[$fromId]]); + } + // 3. A gyártó rekordok rendezése foreach ($merges as $merge) { if ($merge['rename']) { @@ -572,6 +590,15 @@ public function apply(array $merges): array )), 'updated_at' => now(), ]); + + // A régi név mostantól alias - az árlisták ezt még használhatják. + $this->writeAlias($merge['keeper_id'], $from['name'], $merge['final_name'], $report); + } + + // Ha a keeper is átnevezésre került, a SAJÁT eredeti neve is elveszne - + // ez a jelentésen kívül sehol nem marad meg, ezért ezt is aliasként mentjük. + if ($merge['rename']) { + $this->writeAlias($merge['keeper_id'], $merge['keeper_name'], $merge['final_name'], $report); } $report['merges'][] = [ @@ -584,6 +611,52 @@ public function apply(array $merges): array return $report; } + /** + * Egy régi név aliasként mentése a keeperhez. Ütközés esetén nem szakítja meg a + * végrehajtást (a csoportosítás elvileg már ütközésmentes, ez csak védőháló) - + * helyette figyelmeztetést gyűjt a jelentésbe. + */ + private function writeAlias(int $keeperId, string $candidateName, string $liveName, array &$report): void + { + $normalized = NameNormalizer::normalize($candidateName); + + if ($normalized === NameNormalizer::normalize($liveName)) { + return; // megegyezik az élő névvel, felesleges alias lenne + } + + // Előfordulhat, hogy a csoport két tagja (pl. a vesztes neve és a keeper + // átnevezés előtti neve) normalizálva ugyanarra esik - ilyenkor a második írás + // a DB unique indexbe ütközne. Explicit kezeljük, mert az assertNameAvailable + // az ignoreProducerId miatt "sajátként" engedné át, holott ez már létezik. + $existing = ProducerAlias::where('normalized_name', $normalized)->first(); + + if ($existing) { + if ($existing->producer_id !== $keeperId) { + $report['alias_warnings'][] = "A(z) \"{$candidateName}\" már alias a(z) #{$existing->producer_id} " + . "gyártóhoz, nem írható át a(z) #{$keeperId} alá."; + } + + return; + } + + try { + $this->aliasResolver->assertNameAvailable($candidateName, $keeperId); + } catch (RuntimeException $e) { + $report['alias_warnings'][] = $e->getMessage(); + + return; + } + + $alias = ProducerAlias::create([ + 'producer_id' => $keeperId, + 'name' => $candidateName, + 'normalized_name' => NameNormalizer::normalize($candidateName), + 'source' => 'dedupe', + ]); + + $report['restore']['created_alias_ids'][] = $alias->id; + } + /** * Egyetlen UPDATE táblánként, CASE leképezéssel. */ @@ -649,6 +722,14 @@ public function rollback(array $report): array ]); } + // Alias visszagörgetés: az apply() által létrehozott aliasok törlése, az + // időközben átpontozottak visszaállítása az eredeti (akkor még aktív) gyártóra. + ProducerAlias::whereIn('id', (array) ($report['restore']['created_alias_ids'] ?? []))->delete(); + + foreach ((array) ($report['restore']['repointed_aliases'] ?? []) as $aliasId => $originalProducerId) { + ProducerAlias::where('id', (int) $aliasId)->update(['producer_id' => (int) $originalProducerId]); + } + return $restored; } } diff --git a/tests/Feature/ProducerDedupeTest.php b/tests/Feature/ProducerDedupeTest.php index d9c5608..3a97afd 100644 --- a/tests/Feature/ProducerDedupeTest.php +++ b/tests/Feature/ProducerDedupeTest.php @@ -3,6 +3,7 @@ use App\Console\Commands\ProducersDedupeReport; use App\Enums\DbStatusFieldEnum; use App\Models\Producer; +use App\Models\ProducerAlias; use App\Models\Product; use App\Services\ProducerDeduplicator; use Illuminate\Foundation\Testing\RefreshDatabase; @@ -275,6 +276,120 @@ function decisionsFor(array $rows): array ->and($loser->note)->toBeNull(); }); +test('az összevonás aliast ír a beolvasztott gyártó nevéből', function () { + $keeper = producer('Danone'); + $loser = producer('Danone Kft'); + + $plan = $this->deduplicator->buildPlan(decisionsFor([ + ['id' => $keeper->id, 'final_name' => 'Danone'], + ['id' => $loser->id, 'final_name' => null], + ])); + + $this->deduplicator->apply($plan['merges']); + + expect(ProducerAlias::where('producer_id', $keeper->id)->pluck('name')->all())->toBe(['Danone Kft']); +}); + +test('átnevezésnél a keeper eredeti neve is aliassá válik', function () { + $keeper = producer('Danone'); + $loser = producer('Danone Kft'); + + $plan = $this->deduplicator->buildPlan(decisionsFor([ + ['id' => $keeper->id, 'final_name' => 'Danone Magyarország'], + ['id' => $loser->id, 'final_name' => null], + ])); + + $this->deduplicator->apply($plan['merges']); + + expect(ProducerAlias::where('producer_id', $keeper->id)->pluck('name')->sort()->values()->all()) + ->toBe(['Danone', 'Danone Kft']); +}); + +test('ha a vesztes és a keeper eredeti neve normalizálva egyezik, csak egy aliast ír', function () { + // "danone" és "Danone " normalizálva ugyanaz - a második írás a DB unique + // indexébe ütközne, ha nem lenne explicit kezelve. + $keeper = producer('danone'); + $loser = producer('Danone '); + + $plan = $this->deduplicator->buildPlan(decisionsFor([ + ['id' => $keeper->id, 'final_name' => 'Danone Magyarország'], + ['id' => $loser->id, 'final_name' => null], + ])); + + $this->deduplicator->apply($plan['merges']); + + expect(ProducerAlias::count())->toBe(1); +}); + +test('a korábban keeperként szolgáló, most vesztes gyártó aliasai átpontozódnak', function () { + $originalKeeper = producer('Danone'); + $originalLoser = producer('Danone Kft'); + + $firstPlan = $this->deduplicator->buildPlan(decisionsFor([ + ['id' => $originalKeeper->id, 'final_name' => 'Danone'], + ['id' => $originalLoser->id, 'final_name' => null], + ])); + $this->deduplicator->apply($firstPlan['merges']); + + $alias = ProducerAlias::where('producer_id', $originalKeeper->id)->sole(); + expect($alias->name)->toBe('Danone Kft'); + + // A korábbi keeper most maga is beolvad egy újabb, nagyobb gyártóba. A + // sortByKeeperPriority a legtöbb termékkel rendelkezőt választja keepernek - + // termék nélkül a régebbi (kisebb ID-jű) rekord nyerne, ezért kell a termék ide. + $newKeeper = producer('Danone Csoport'); + productFor($newKeeper, 'X1'); + $secondPlan = $this->deduplicator->buildPlan(decisionsFor([ + ['id' => $newKeeper->id, 'final_name' => 'Danone Csoport'], + ['id' => $originalKeeper->id, 'final_name' => null], + ])); + $this->deduplicator->apply($secondPlan['merges']); + + // Az alias nem árválódhat el: követnie kell a láncot az új keeperig. + expect($alias->refresh()->producer_id)->toBe($newKeeper->id); +}); + +test('ütköző alias-jelöltet nem ír be, csak figyelmeztetést gyűjt a jelentésbe', function () { + // Közvetlenül az apply()-t hívjuk, buildPlan() nélkül, mert a lap-validáció + // (validateGrouping) blokkolná ezt a mesterséges elrendezést, mielőtt elérnénk + // az apply() saját, védőhálóként szolgáló ütközés-ellenőrzését. + producer('Bonduelle'); + $keeper = producer('Danone'); + $loser = producer('Régi Danone Név'); + + $report = $this->deduplicator->apply([[ + 'keeper_id' => $keeper->id, + 'keeper_name' => $keeper->name, + 'final_name' => $keeper->name, + 'rename' => false, + 'from' => [['id' => $loser->id, 'name' => 'Bonduelle']], // szándékos ütközés + ]]); + + expect(ProducerAlias::count())->toBe(0) + ->and($report['alias_warnings'])->toHaveCount(1) + ->and($report['alias_warnings'][0])->toContain('Bonduelle'); + + // A gyártó-archiválás maga nem marad el az alias-ütközés miatt. + expect($loser->refresh()->status)->toBe(DbStatusFieldEnum::archive); +}); + +test('a visszagörgetés törli a létrehozott és visszaállítja az átpontozott aliasokat', function () { + $keeper = producer('Danone'); + $loser = producer('Danone Kft'); + + $plan = $this->deduplicator->buildPlan(decisionsFor([ + ['id' => $keeper->id, 'final_name' => 'Danone'], + ['id' => $loser->id, 'final_name' => null], + ])); + $report = $this->deduplicator->apply($plan['merges']); + + expect(ProducerAlias::count())->toBe(1); + + $this->deduplicator->rollback($report); + + expect(ProducerAlias::count())->toBe(0); +}); + test('a döntési lap legenerálható és visszaolvasható', function () { $keeper = producer('Danone'); $loser = producer('Danone ');