ADD EV3-473 producers:dedupe automatikus alias-írása összevonáskor

A ProducerDeduplicator::apply() mostantól minden összevonáskor aliast ír a
vesztes gyártók nevéből, és átnevezésnél a keeper eredeti nevéből is - ez
utóbbi sehol máshol nem maradna meg. Ha egy vesztesnek már volt alias-a egy
korábbi összevonásból, azt átpontozza az új keeperre, nehogy elárvuljon.
Ütközésnél a végrehajtás nem szakad meg, csak figyelmeztetést gyűjt a
jelentésbe. A rollback() mindkét műveletet szimmetrikusan visszagörgeti.
This commit is contained in:
E98Developer 2026-09-19 05:48:34 +02:00
parent 5347ac5518
commit 80564c87a2
3 changed files with 200 additions and 0 deletions

View File

@ -100,6 +100,10 @@ public function handle(ProducerDeduplicator $deduplicator): int
foreach ($report['totals'] as $table => $count) { foreach ($report['totals'] as $table => $count) {
$this->line(' ' . str_pad($table, 24) . number_format($count) . ' sor átírva'); $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->line(' Jelentés: ' . $reportPath);
$this->newLine(); $this->newLine();
$this->comment('Visszagörgetés: php artisan producers:dedupe --rollback="' . $reportPath . '"'); $this->comment('Visszagörgetés: php artisan producers:dedupe --rollback="' . $reportPath . '"');

View File

@ -3,8 +3,11 @@
namespace App\Services; namespace App\Services;
use App\Enums\DbStatusFieldEnum; use App\Enums\DbStatusFieldEnum;
use App\Models\ProducerAlias;
use App\Support\NameNormalizer; use App\Support\NameNormalizer;
use App\Support\ProducerAliasResolver;
use Illuminate\Support\Facades\DB; use Illuminate\Support\Facades\DB;
use RuntimeException;
/** /**
* Duplikált gyártó törzsadat felderítése és összevonása. * Duplikált gyártó törzsadat felderítése és összevonása.
@ -43,6 +46,8 @@ class ProducerDeduplicator
public const DIFF_MIXED = 'vegyes'; 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. * 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). * A tagok rendezettek: az első a javasolt megtartandó (legtöbb termék).
@ -516,6 +521,7 @@ public function apply(array $merges): array
'merges' => [], 'merges' => [],
'restore' => [], 'restore' => [],
'totals' => array_fill_keys(array_keys(self::REFERENCING_TABLES), 0), 'totals' => array_fill_keys(array_keys(self::REFERENCING_TABLES), 0),
'alias_warnings' => [],
]; ];
// producer_id leképezés: honnan => hova // 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['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 // 3. A gyártó rekordok rendezése
foreach ($merges as $merge) { foreach ($merges as $merge) {
if ($merge['rename']) { if ($merge['rename']) {
@ -572,6 +590,15 @@ public function apply(array $merges): array
)), )),
'updated_at' => now(), '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'][] = [ $report['merges'][] = [
@ -584,6 +611,52 @@ public function apply(array $merges): array
return $report; 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. * 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; return $restored;
} }
} }

View File

@ -3,6 +3,7 @@
use App\Console\Commands\ProducersDedupeReport; use App\Console\Commands\ProducersDedupeReport;
use App\Enums\DbStatusFieldEnum; use App\Enums\DbStatusFieldEnum;
use App\Models\Producer; use App\Models\Producer;
use App\Models\ProducerAlias;
use App\Models\Product; use App\Models\Product;
use App\Services\ProducerDeduplicator; use App\Services\ProducerDeduplicator;
use Illuminate\Foundation\Testing\RefreshDatabase; use Illuminate\Foundation\Testing\RefreshDatabase;
@ -275,6 +276,120 @@ function decisionsFor(array $rows): array
->and($loser->note)->toBeNull(); ->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 () { test('a döntési lap legenerálható és visszaolvasható', function () {
$keeper = producer('Danone'); $keeper = producer('Danone');
$loser = producer('Danone '); $loser = producer('Danone ');