d2d.emegrendeles.hu/app/Services/ProducerDeduplicator.php
E98Developer bd41dabc5a ADD EV3-473 gyártó-összevonás felületről ütközés feloldásához
Valódi tesztelés közben előkerült eset (két aktív gyártó, pl. "Szarvas" és
"Szarvasi"): az alias-felvétel eddig csak elutasította az ütközést, de nem
adott módot a tényleges összevonásra a felületről - csak a
producers:dedupe-report -> Excel -> producers:dedupe --apply láncon
keresztül, fejlesztői hozzáféréssel.

Új "Gyártó összevonása" gomb a megtekintő oldalon: a nézett gyártó marad a
keeper, a kiválasztott aktív gyártó beolvad, a neve automatikusan aliasként
kerül fel. A ProducerDeduplicator::apply() egyetlen kézzel épített
merge-bejegyzéssel hívva, Excel nélkül. A jelentés fájlba írása kiemelve a
CLI parancsból, hogy a felületi összevonás is CLI-vel visszagörgethető
maradjon.

Az alias-ütközés hibaüzenete (ha aktív gyártóval ütközik) mostantól a
dedikált ActiveProducerNameCollisionException-on át utal az összevonás
gombra.

Mellékesen javítva: a jelentés-fájlnév másodperc pontosságú volt, ami egy
másodpercen belüli két összevonásnál csendben felülírta volna az előzőt
(mikroszekundumra pontosítva), és az Aliasok relation manager nem frissült
a más komponensről történő összevonás után (5s poll, ugyanaz a minta, mint
a LinesRelationManager-en).
2026-09-19 07:19:12 +02:00

759 lines
29 KiB
PHP
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<?php
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.
*
* A duplikátumok onnan származnak, hogy a legacy árlista import karakterre pontos
* egyezést követelt a gyártónévre, és találat híján újat vett fel a nyers Excel
* értékkel - így lett a "Danone" mellett "Danone " is. Két helyen fáj:
*
* - az árlista feldolgozó valódi változás nélkül is módosulást jelez, mert a termék
* az egyik, a névfeloldás a másik rekordra mutat,
* - a Termék mennyiség statisztika gyártóra szűrve a másik ID alá könyvelt tételeket
* kihagyja a riportból.
*
* A keletkezés útját a NameNormalizer bevezetése zárta le; ez az osztály a már
* felhalmozódott adatot takarítja.
*/
class ProducerDeduplicator
{
/** A hivatkozó táblák: tábla => oszlop. FK csak a pricelist_file_lines-on van. */
public const REFERENCING_TABLES = [
'products' => 'producer_id',
'order_archives_items' => 'producer_id',
'pricelist_file_lines' => 'producer_id',
];
private const UPDATE_CHUNK = 5000;
/** Az eltérés jellege egy laza jelölt-csoportban (lásd differenceCategory) */
public const DIFF_PUNCTUATION = 'csak írásjel';
public const DIFF_SPACING = 'egybeírás';
public const DIFF_ACCENT = 'ékezet';
public const DIFF_COMPANY_FORM = 'cégforma';
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).
*
* @return array<string, array<int, array{producer: object, counts: array<string, int>}>>
*/
public function duplicateGroups(): array
{
$byNormalized = [];
foreach ($this->activeMembers() as $member) {
$byNormalized[NameNormalizer::normalize($member['producer']->name)][] = $member;
}
$groups = [];
foreach ($byNormalized as $normalized => $members) {
if (count($members) < 2) {
continue;
}
$groups[$normalized] = $this->sortByKeeperPriority($members);
}
ksort($groups);
return $groups;
}
/**
* Laza jelöltek: olyan gyártók, amelyeket a szigorú szabály NEM köt össze, de nagy
* eséllyel ugyanaz a cég - elírás, kötőjel, egybeírás, hiányzó ékezet miatt térnek el.
*
* Ezek SOSEM olvadnak össze maguktól: a riportba javaslatként kerülnek, a döntést a
* megrendelő hozza. Ezért lehet itt megengedőbb a szabály, mint az import-párosításnál,
* ahol egy téves egyezés csendben rossz gyártóhoz rendelne termékeket.
*
* Egy dolgot viszont itt is tiszteletben tartunk: a KÜLÖNBÖZŐ cégforma (Kft vs Zrt)
* valódi különbség, nem elírás - azokat nem javasoljuk összevonásra. A cégforma
* nélküli név viszont párba állhat egy cégformással, ha csak egyféle forma van.
*
* @return array<string, array<int, array{producer: object, counts: array<string, int>}>>
*/
public function looseCandidateGroups(): array
{
$byBase = [];
foreach ($this->activeMembers() as $member) {
[$base, $form] = $this->splitCompanyForm($member['producer']->name);
if ($base === '') {
continue;
}
$byBase[$base][$form][] = $member;
}
$candidates = [];
foreach ($byBase as $base => $byForm) {
$explicitForms = array_diff(array_keys($byForm), ['']);
if (count($explicitForms) > 1) {
// Kft ÉS Zrt is van ugyanarra a névre: ezek nem egymás elírásai. A
// formánként külön csoportok mehetnek, a forma nélküli viszont nem
// rendelhető egyértelműen egyikhez sem, ezért kimarad.
foreach ($explicitForms as $form) {
$candidates[$base . '|' . $form] = $byForm[$form];
}
continue;
}
$candidates[$base] = array_merge(...array_values($byForm));
}
// Csak az érdekes: ami több szigorú csoportot fog össze (vagy olyan rekordokat,
// amiket a szigorú szabály külön hagyott).
$strictKeys = [];
foreach ($candidates as $key => $members) {
$strictKeys[$key] = array_unique(array_map(
fn ($m) => NameNormalizer::normalize($m['producer']->name),
$members,
));
}
$result = [];
foreach ($candidates as $key => $members) {
if (count($members) < 2 || count($strictKeys[$key]) < 2) {
continue;
}
$result[$key] = $this->sortByKeeperPriority($members);
}
ksort($result);
return $result;
}
/**
* Egy laza jelölt-csoport eltérésének jellege - a LEGKEVÉSBÉ agresszív átalakítás,
* ami már egy kulcsra hozza a tagokat.
*
* Ez adja meg a megrendelőnek, mennyi mérlegelést igényel a sor: a "csak írásjel"
* eseteknél gyakorlatilag nincs döntés, a "cégforma" és a "vegyes" viszont valódi
* ismeretet kíván a cégekről.
*
* @param array<int, array{producer: object, counts: array<string, int>}> $members
*/
public function differenceCategory(array $members): string
{
$names = array_map(fn ($m) => (string) $m['producer']->name, $members);
$levels = [
self::DIFF_PUNCTUATION => fn ($n) => $this->stripPunctuation(NameNormalizer::normalize($n)),
self::DIFF_SPACING => fn ($n) => preg_replace('/\s+/u', '',
$this->stripPunctuation(NameNormalizer::normalize($n))),
self::DIFF_ACCENT => fn ($n) => preg_replace('/\s+/u', '',
$this->stripAccents($this->stripPunctuation(NameNormalizer::normalize($n)))),
self::DIFF_COMPANY_FORM => fn ($n) => $this->splitCompanyForm($n)[0],
];
foreach ($levels as $category => $key) {
if (count(array_unique(array_map($key, $names))) === 1) {
return $category;
}
}
return self::DIFF_MIXED;
}
private function stripPunctuation(string $text): string
{
return trim(preg_replace('/\s+/u', ' ', preg_replace('/[.,\-\'"()]/u', ' ', $text) ?? $text) ?? $text);
}
private function stripAccents(string $text): string
{
return strtr($text, [
'Á' => 'A', 'É' => 'E', 'Í' => 'I', 'Ó' => 'O', 'Ö' => 'O',
'Ő' => 'O', 'Ú' => 'U', 'Ü' => 'U', 'Ű' => 'U',
]);
}
/**
* Név szétbontása alapnévre és cégforma-toldatra, a "csak elírás" eltérések
* kiszűrésével: írásjelek, ékezetek és szóközök elhagyásával.
*
* @return array{0: string, 1: string} [alapnév, cégforma]
*/
private function splitCompanyForm(string $name): array
{
$normalized = $this->stripAccents($this->stripPunctuation(NameNormalizer::normalize($name)));
$form = '';
$pattern = '/\b(KFT|ZRT|BT|NYRT|KKT|RT|GMBH|LTD|INC|SRL|NV|BV|AG|SA|SPA)\b/u';
if (preg_match($pattern, $normalized, $matches)) {
$form = $matches[1];
$normalized = preg_replace($pattern, ' ', $normalized) ?? $normalized;
}
// A szóközök teljes elhagyása fogja meg az egybeírást ("Alfölditej" = "Alföldi Tej")
return [preg_replace('/\s+/u', '', $normalized) ?? '', $form];
}
/**
* @return array<int, array{producer: object, counts: array<string, int>}>
*/
private function activeMembers(): array
{
$counts = $this->referenceCounts();
return DB::table('producers')
->whereNotIn('status', [DbStatusFieldEnum::archive, DbStatusFieldEnum::deleted])
->orderBy('id')
->get()
->map(fn ($producer) => [
'producer' => $producer,
'counts' => [
'products' => $counts['products'][$producer->id] ?? 0,
'order_archives_items' => $counts['order_archives_items'][$producer->id] ?? 0,
'pricelist_file_lines' => $counts['pricelist_file_lines'][$producer->id] ?? 0,
],
])
->all();
}
/**
* A megtartandó rekord kerül előre: a legtöbb TERMÉKKEL rendelkező, mert így mozdul
* a legkevesebb sor. Döntetlennél a több rendelési tétel, majd a régebbi rekord.
*
* @param array<int, array> $members
* @return array<int, array>
*/
private function sortByKeeperPriority(array $members): array
{
usort($members, function ($a, $b) {
return [$b['counts']['products'], $b['counts']['order_archives_items'], $a['producer']->id]
<=> [$a['counts']['products'], $a['counts']['order_archives_items'], $b['producer']->id];
});
return array_values($members);
}
/**
* @return array<string, array<int, int>> tábla => [producer_id => darab]
*/
private function referenceCounts(): array
{
$counts = [];
foreach (self::REFERENCING_TABLES as $table => $column) {
$counts[$table] = DB::table($table)
->selectRaw("{$column} as pid, COUNT(*) as c")
->whereNotNull($column)
->groupBy($column)
->pluck('c', 'pid')
->toArray();
}
return $counts;
}
/**
* Összevonási terv a döntési lap sorai alapján.
*
* A csoportosítás forrása a LAP "Csoport" oszlopa, nem az adatbázis normalizálása.
* Ez azért fontos, mert a megrendelő olyan gyártókat is egybe akarhat vonni, amiket a
* névnormalizálás nem tud összekötni: a "Kőröstej" és a "Kőröstej Kft" ugyanaz a cég,
* de a nevük érdemben különbözik. Ha a lap ezeket egy csoportba teszi, itt is egy
* összevonás lesz belőlük - így nem kell a végrehajtásba csoportokon átívelő logika.
*
* @param array<int, array{group: int|string, id: int, final_name: ?string}> $decisions
* @return array{merges: array<int, array>, errors: array<int, string>}
*/
public function buildPlan(array $decisions): array
{
$groups = $this->duplicateGroups();
$memberById = [];
foreach ($this->activeMembers() as $member) {
$memberById[$member['producer']->id] = $member;
}
$normalizedById = [];
foreach ($groups as $normalized => $members) {
foreach ($members as $member) {
$normalizedById[$member['producer']->id] = $normalized;
}
}
$sheetGroups = [];
$finalNames = [];
$skipped = [];
$errors = [];
foreach ($decisions as $row) {
$id = (int) ($row['id'] ?? 0);
if (! isset($memberById[$id])) {
$errors[] = "A(z) {$id} azonosítójú gyártó nem található (vagy már összevonták, "
. 'vagy más környezetből származik a lap).';
continue;
}
$key = trim((string) ($row['group'] ?? ''));
if ($key === '') {
$errors[] = "A(z) {$id} azonosítójú sorból hiányzik a csoport száma.";
continue;
}
$sheetGroups[$key][] = $id;
$name = trim((string) ($row['final_name'] ?? ''));
if ($name !== '') {
$finalNames[$key] ??= $name;
}
}
$validation = $this->validateGrouping($sheetGroups, $normalizedById, $groups);
$errors = array_merge($errors, $validation['errors']);
$merges = [];
foreach ($sheetGroups as $key => $ids) {
// A hibás csoportot NEM hajtjuk végre: egy hiányzó tag azt jelentené, hogy
// az összevonás után is maradna azonos nevű rekord.
if (isset($validation['invalid'][$key])) {
continue;
}
$members = array_values(array_map(fn ($id) => $memberById[$id], array_unique($ids)));
// Üres végleges név = a megrendelő NEM kéri az összevonást. Ez a laza
// javaslatok elutasításának módja, ezért nem hiba, hanem kihagyás - de
// jelentjük, hogy egy véletlen kihagyás se maradjon észrevétlen.
if (! isset($finalNames[$key])) {
$skipped[] = [
'group' => $key,
'names' => array_map(fn ($m) => (string) $m['producer']->name, $members),
];
continue;
}
$members = $this->sortByKeeperPriority($members);
$keeper = $members[0]['producer'];
$losers = array_slice($members, 1);
if ($losers === []) {
continue; // egytagú csoport: nincs mit összevonni
}
$merges[] = [
'group' => $key,
'keeper_id' => $keeper->id,
'keeper_name' => $keeper->name,
'final_name' => $finalNames[$key],
'rename' => trim((string) $keeper->name) !== $finalNames[$key],
'from' => array_map(fn ($m) => [
'id' => $m['producer']->id,
'name' => $m['producer']->name,
'counts' => $m['counts'],
], $losers),
];
}
return [
'merges' => $merges,
'errors' => $errors,
'skipped' => $skipped,
'blocking' => $this->detectNameCollisions($merges),
];
}
/**
* Névütközés: két gyártó ugyanarra a névre kerülne a végrehajtás után.
*
* Ez akkor fordul elő, ha a megrendelő két KÜLÖN lap-csoportnak ugyanazt a végleges
* nevet adja (a szándéka szerint egy cégről van szó), vagy ha a végleges név egy
* olyan gyártó neve, amely nem vesz részt az összevonásban. Mindkét esetben két
* azonos nevű aktív gyártó maradna - vagyis a takarítás maga állítana elő
* duplikátumot. Ezért ez BLOKKOLÓ hiba: a végrehajtás csak a lap javítása (a
* csoportok egybetétele) után indulhat, és a --force sem kerüli meg.
*
* @param array<int, array> $merges
* @return array<int, string>
*/
private function detectNameCollisions(array $merges): array
{
$mergedAway = [];
$keeperGroup = [];
$keeperFinalName = [];
foreach ($merges as $merge) {
$keeperGroup[$merge['keeper_id']] = $merge['group'];
$keeperFinalName[$merge['keeper_id']] = $merge['final_name'];
foreach ($merge['from'] as $from) {
$mergedAway[$from['id']] = true;
}
}
// A végrehajtás UTÁNI aktív névállomány
$resulting = [];
foreach ($this->activeMembers() as $member) {
$producer = $member['producer'];
if (isset($mergedAway[$producer->id])) {
continue;
}
$name = $keeperFinalName[$producer->id] ?? (string) $producer->name;
$resulting[NameNormalizer::normalize($name)][] = [
'id' => $producer->id,
'name' => $name,
'group' => $keeperGroup[$producer->id] ?? null,
];
}
$blocking = [];
foreach ($resulting as $entries) {
// Csak azt jelezzük, amit EZ a terv okoz - a lapon kívüli, már meglévő
// duplikátumokat nem (azok egy következő kör dolgai).
if (count($entries) < 2 || array_filter(array_column($entries, 'group'), fn ($g) => $g !== null) === []) {
continue;
}
$parts = array_map(fn ($e) => $e['group'] !== null
? $e['group'] . '. csoport (#' . $e['id'] . ')'
: 'a lapon kívüli #' . $e['id'] . ' gyártó', $entries);
$blocking[] = 'Névütközés: ' . implode(' és ', $parts) . ' ugyanarra a névre kerülne: "'
. $entries[0]['name'] . '". Ha ugyanaz a cég, tedd őket egy csoportba (azonos '
. 'csoportszám); ha nem, adj nekik eltérő végleges nevet.';
}
return $blocking;
}
/**
* A lap-csoportosítás ellenőrzése.
*
* A lap SZÉLESEBB csoportot csinálhat, mint a névnormalizálás (ez a cél), de
* SZŰKEBBET nem: ha az azonos nevű rekordok külön lap-csoportba kerülnének, a
* végén két azonos nevű gyártó maradna - vagyis pont a duplikációt állítanánk elő.
*
* @return array{errors: array<int, string>, invalid: array<string, true>}
*/
private function validateGrouping(array $sheetGroups, array $normalizedById, array $groups): array
{
$errors = [];
$invalid = [];
$sheetKeysByNormalized = [];
$idsByNormalized = [];
foreach ($sheetGroups as $key => $ids) {
foreach ($ids as $id) {
// A lapon szerepelhet olyan gyártó is, ami NEM tagja szigorú duplikátum
// csoportnak (a laza javaslatok ilyenek) - ott nincs mit ellenőrizni.
if (! isset($normalizedById[$id])) {
continue;
}
$normalized = $normalizedById[$id];
$sheetKeysByNormalized[$normalized][$key] = true;
$idsByNormalized[$normalized][$id] = true;
}
}
foreach ($sheetKeysByNormalized as $normalized => $keys) {
if (count($keys) > 1) {
$errors[] = 'Az azonos nevű gyártók ("' . $normalized . '") több csoportba kerültek a lapon ('
. implode(', ', array_keys($keys)) . '). Ezeket egy csoportba kell tenni, '
. 'különben duplikátum maradna utánuk.';
foreach (array_keys($keys) as $key) {
$invalid[$key] = true;
}
}
$expected = array_map(fn ($m) => $m['producer']->id, $groups[$normalized]);
$missing = array_diff($expected, array_keys($idsByNormalized[$normalized]));
if ($missing !== []) {
$errors[] = 'A döntési lap nem tartalmazza a csoport minden tagját (hiányzó azonosító: '
. implode(', ', $missing) . '). Generáld újra a lapot ebben a környezetben.';
foreach (array_keys($keys) as $key) {
$invalid[$key] = true;
}
}
}
return ['errors' => $errors, 'invalid' => $invalid];
}
/**
* A terv végrehajtása. Előbb visszaállítási pontot ír, csak utána módosít.
*
* @return array a jelentés, ami egyben a visszagörgetés bemenete is
*/
public function apply(array $merges): array
{
$report = [
'created_at' => now()->toDateTimeString(),
'database' => DB::connection()->getDatabaseName(),
'merges' => [],
'restore' => [],
'totals' => array_fill_keys(array_keys(self::REFERENCING_TABLES), 0),
'alias_warnings' => [],
];
// producer_id leképezés: honnan => hova
$map = [];
foreach ($merges as $merge) {
foreach ($merge['from'] as $from) {
$map[$from['id']] = $merge['keeper_id'];
}
}
if ($map === []) {
return $report;
}
// 1. Visszaállítási pont: soronként a régi érték. Enélkül a művelet nem lenne
// visszafordítható, mert a fordított leképezés azokat a sorokat is átírná,
// amelyek eredetileg is a megtartott rekordra mutattak.
foreach (self::REFERENCING_TABLES as $table => $column) {
$report['restore'][$table] = DB::table($table)
->whereIn($column, array_keys($map))
->pluck($column, 'id')
->toArray();
}
$report['restore']['producers'] = DB::table('producers')
->whereIn('id', array_merge(array_keys($map), array_column($merges, 'keeper_id')))
->get(['id', 'name', 'status', 'canSee', 'note'])
->keyBy('id')
->toArray();
// 2. Hivatkozások átírása - táblánként EGY menetben, mert a producer_id-n a nagy
// táblákon nincs index, tehát minden külön WHERE teljes scant jelentene.
foreach (self::REFERENCING_TABLES as $table => $column) {
$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']) {
DB::table('producers')->where('id', $merge['keeper_id'])
->update(['name' => $merge['final_name'], 'updated_at' => now()]);
}
foreach ($merge['from'] as $from) {
DB::table('producers')->where('id', $from['id'])->update([
'status' => DbStatusFieldEnum::archive,
'canSee' => 0,
// Tartós nyom az adatbázisban: a jelentésfájl elveszhet, ez nem.
'note' => trim(sprintf(
'Összevonva ide: #%d (%s) – %s producers:dedupe',
$merge['keeper_id'],
$merge['final_name'],
now()->toDateString(),
)),
'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'][] = [
'keeper_id' => $merge['keeper_id'],
'final_name' => $merge['final_name'],
'from' => array_map(fn ($f) => ['id' => $f['id'], 'name' => $f['name']], $merge['from']),
];
}
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.
*/
private function remap(string $table, string $column, array $map): int
{
$ids = array_map('intval', array_keys($map));
$updated = 0;
foreach (array_chunk($ids, 200) as $chunk) {
$cases = '';
foreach ($chunk as $from) {
$cases .= sprintf(' WHEN %d THEN %d', $from, (int) $map[$from]);
}
$updated += DB::update(sprintf(
'UPDATE `%s` SET `%s` = CASE `%s`%s END WHERE `%s` IN (%s)',
$table,
$column,
$column,
$cases,
$column,
implode(',', $chunk),
));
}
return $updated;
}
/**
* Visszagörgetés a jelentésfájlból: minden érintett sor visszakapja a saját,
* eredeti producer_id-ját, a gyártó rekordok pedig az eredeti nevüket/státuszukat.
*/
public function rollback(array $report): array
{
$restored = array_fill_keys(array_keys(self::REFERENCING_TABLES), 0);
foreach (self::REFERENCING_TABLES as $table => $column) {
$rows = (array) ($report['restore'][$table] ?? []);
foreach (array_chunk($rows, self::UPDATE_CHUNK, true) as $chunk) {
$byValue = [];
foreach ($chunk as $rowId => $producerId) {
$byValue[(int) $producerId][] = (int) $rowId;
}
foreach ($byValue as $producerId => $rowIds) {
$restored[$table] += DB::table($table)
->whereIn('id', $rowIds)
->update([$column => $producerId]);
}
}
}
foreach ((array) ($report['restore']['producers'] ?? []) as $id => $producer) {
$producer = (array) $producer;
DB::table('producers')->where('id', (int) $id)->update([
'name' => $producer['name'],
'status' => $producer['status'],
'canSee' => $producer['canSee'],
'note' => $producer['note'],
'updated_at' => now(),
]);
}
// 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;
}
/**
* A jelentés lemezre írása - ugyanabba a helyre és ugyanolyan formában, akár a CLI
* `producers:dedupe --report`, akár a felületi gyártó-összevonás (EV3-473, 7. lépés)
* hívja. Enélkül egy felületről indított összevonás nem lenne fejlesztői kézzel
* visszagörgethető a meglévő `producers:dedupe --rollback`-kal.
*/
public function writeReport(array $report, ?string $path = null): string
{
// Mikroszekundum a névben: a felületi összevonás (EV3-473, 7. lépés) miatt már
// reális, hogy egy másodpercen belül több jelentés is készül - a másodperc
// pontosságú név csendben felülírta volna az előzőt.
$path ??= storage_path('app/private/producers-dedupe-' . now()->format('Y-m-d_His_u') . '.json');
$directory = dirname($path);
if (! is_dir($directory)) {
mkdir($directory, 0775, true);
}
file_put_contents($path, json_encode($report, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE));
return $path;
}
}