diff --git a/app/Models/Producer.php b/app/Models/Producer.php index 896df14..3ccb265 100644 --- a/app/Models/Producer.php +++ b/app/Models/Producer.php @@ -2,4 +2,10 @@ namespace App\Models; -class Producer extends BaseAuditable {} +class Producer extends BaseAuditable +{ + public function aliases() + { + return $this->hasMany(ProducerAlias::class); + } +} diff --git a/app/Models/ProducerAlias.php b/app/Models/ProducerAlias.php new file mode 100644 index 0000000..3d2f2bd --- /dev/null +++ b/app/Models/ProducerAlias.php @@ -0,0 +1,11 @@ +belongsTo(Producer::class); + } +} diff --git a/app/Services/PricelistFileProcessService.php b/app/Services/PricelistFileProcessService.php index f36a9d4..be6ff44 100644 --- a/app/Services/PricelistFileProcessService.php +++ b/app/Services/PricelistFileProcessService.php @@ -8,6 +8,7 @@ use App\Models\PriceList; use App\Models\PricelistFile; use App\Support\NameNormalizer; +use App\Support\ProducerAliasResolver; use App\Enums\PricelistFileStatusEnum; use App\Models\PricelistFileLine; use App\Enums\PricelistFileLineStatusEnum; @@ -871,12 +872,20 @@ protected function getProducerLookupMap(): array // Az összevont (archive) és a törölt gyártók kimaradnak: enélkül a // duplikáció-takarítás hatástalan lenne, mert a beolvasztott rekord // továbbra is visszakerülne a feloldásba. - return \App\Models\Producer::query() + $producerMap = \App\Models\Producer::query() ->whereNotIn('status', [DbStatusFieldEnum::archive, DbStatusFieldEnum::deleted]) ->get() ->keyBy(fn($p) => $this->normalizeForComparison($p->name)) ->map->id ->toArray(); + + // Az árlisták a beolvasztott, régi gyártóneveket is használják. A producer-térkép + // áll a `+` operátor BAL oldalán, hogy egyezés esetén az ő bejegyzése nyerjen + // (a `+` a bal oldali értéket tartja meg ütköző kulcsnál) - az alias sosem írhat + // felül élő gyártónevet. + $aliasMap = (new ProducerAliasResolver)->lookupMap(); + + return $producerMap + $aliasMap; } /** diff --git a/app/Support/ProducerAliasResolver.php b/app/Support/ProducerAliasResolver.php new file mode 100644 index 0000000..1d60d86 --- /dev/null +++ b/app/Support/ProducerAliasResolver.php @@ -0,0 +1,68 @@ + + * normalizált név -> alias) ÉS ez az osztály is önállóan biztosítja, hogy egy alias + * írásakor se keletkezhessen ütközés. + */ +class ProducerAliasResolver +{ + /** + * normalized_name => producer_id, csak aktív (nem archive/deleted) gyártóhoz + * tartozó aliasokra. + */ + public function lookupMap(): array + { + return ProducerAlias::query() + ->whereHas('producer', fn ($q) => $q->whereNotIn('status', [ + DbStatusFieldEnum::archive, DbStatusFieldEnum::deleted, + ])) + ->pluck('producer_id', 'normalized_name') + ->toArray(); + } + + /** + * Dob, ha a név normalizált alakja ütközik egy aktív gyártó nevével vagy egy + * másik alias-szal. $ignoreProducerId: az a gyártó, amelyikhez az alias éppen + * készül - a saját neve nem számít ütközésnek. + */ + public function assertNameAvailable(string $name, ?int $ignoreProducerId = null): void + { + $normalized = NameNormalizer::normalize($name); + + if ($normalized === '') { + throw new RuntimeException('Az alias neve nem lehet üres.'); + } + + $collidingProducer = Producer::query() + ->whereNotIn('status', [DbStatusFieldEnum::archive, DbStatusFieldEnum::deleted]) + ->when($ignoreProducerId, fn ($q) => $q->where('id', '!=', $ignoreProducerId)) + ->get(['id', 'name']) + ->first(fn ($p) => NameNormalizer::normalize($p->name) === $normalized); + + if ($collidingProducer) { + throw new RuntimeException( + "A(z) \"{$name}\" név ütközik a(z) #{$collidingProducer->id} ({$collidingProducer->name}) aktív gyártóval." + ); + } + + $collidingAlias = ProducerAlias::where('normalized_name', $normalized) + ->when($ignoreProducerId, fn ($q) => $q->where('producer_id', '!=', $ignoreProducerId)) + ->first(); + + if ($collidingAlias) { + throw new RuntimeException( + "A(z) \"{$name}\" név már alias a(z) #{$collidingAlias->producer_id} gyártóhoz." + ); + } + } +} diff --git a/database/migrations/2026_09_18_120000_create_producer_aliases_table.php b/database/migrations/2026_09_18_120000_create_producer_aliases_table.php new file mode 100644 index 0000000..f0be92f --- /dev/null +++ b/database/migrations/2026_09_18_120000_create_producer_aliases_table.php @@ -0,0 +1,32 @@ +id(); + $table->foreignId('producer_id')->constrained('producers')->cascadeOnDelete(); + $table->string('name'); + $table->string('normalized_name')->unique(); + $table->string('source')->default('backfill'); + $table->timestamps(); + $table->userIdFields(); + }); + } + + /** + * Reverse the migrations. + */ + public function down(): void + { + Schema::dropIfExists('producer_aliases'); + } +}; diff --git a/database/schema/mysql-schema.sql b/database/schema/mysql-schema.sql index 9420f1b..f4384ed 100644 --- a/database/schema/mysql-schema.sql +++ b/database/schema/mysql-schema.sql @@ -634,6 +634,26 @@ CREATE TABLE `pricelist_files` ( CONSTRAINT `pricelist_files_supplier_id_foreign` FOREIGN KEY (`supplier_id`) REFERENCES `suppliers` (`id`) ON DELETE SET NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci; /*!40101 SET character_set_client = @saved_cs_client */; +DROP TABLE IF EXISTS `producer_aliases`; +/*!40101 SET @saved_cs_client = @@character_set_client */; +/*!40101 SET character_set_client = utf8mb4 */; +CREATE TABLE `producer_aliases` ( + `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT, + `producer_id` bigint(20) unsigned NOT NULL, + `name` varchar(255) NOT NULL, + `normalized_name` varchar(255) NOT NULL, + `source` varchar(255) NOT NULL DEFAULT 'backfill', + `created_at` timestamp NULL DEFAULT NULL, + `updated_at` timestamp NULL DEFAULT NULL, + `created_by` int(10) unsigned DEFAULT NULL, + `updated_by` int(10) unsigned DEFAULT NULL, + `deleted_by` int(10) unsigned DEFAULT NULL, + PRIMARY KEY (`id`), + UNIQUE KEY `producer_aliases_normalized_name_unique` (`normalized_name`), + KEY `producer_aliases_producer_id_foreign` (`producer_id`), + CONSTRAINT `producer_aliases_producer_id_foreign` FOREIGN KEY (`producer_id`) REFERENCES `producers` (`id`) ON DELETE CASCADE +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci; +/*!40101 SET character_set_client = @saved_cs_client */; DROP TABLE IF EXISTS `producers`; /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8mb4 */; @@ -1180,4 +1200,5 @@ INSERT INTO `migrations` (`id`, `migration`, `batch`) VALUES (888,'2026_08_10_09 INSERT INTO `migrations` (`id`, `migration`, `batch`) VALUES (889,'2026_08_10_090100_add_execution_fields_to_pricelist_file_lines_table',28); INSERT INTO `migrations` (`id`, `migration`, `batch`) VALUES (890,'2026_08_16_090000_create_deployment_packages_table',29); INSERT INTO `migrations` (`id`, `migration`, `batch`) VALUES (892,'2026_08_24_172116_add_meter_unit_to_seller_and_amount_unit_columns',30); +INSERT INTO `migrations` (`id`, `migration`, `batch`) VALUES (893,'2026_09_18_120000_create_producer_aliases_table',31); commit; diff --git a/tests/Feature/ProducerDuplicationTest.php b/tests/Feature/ProducerDuplicationTest.php index 7530f9c..f0a70b7 100644 --- a/tests/Feature/ProducerDuplicationTest.php +++ b/tests/Feature/ProducerDuplicationTest.php @@ -2,9 +2,11 @@ use App\Enums\DbStatusFieldEnum; use App\Models\Producer; +use App\Models\ProducerAlias; use App\Services\PriceListService; use App\Services\PricelistFileProcessService; use App\Support\NameNormalizer; +use App\Support\ProducerAliasResolver; use Illuminate\Foundation\Testing\RefreshDatabase; use Tests\TestCase; @@ -111,3 +113,76 @@ function makeProducer(string $name, string $status = DbStatusFieldEnum::active): expect($lookup['DANONE'] ?? null)->toBe($active->id) ->and(in_array($merged->id, $lookup, true))->toBeFalse(); }); + +function makeAlias(Producer $producer, string $name, string $source = 'backfill'): ProducerAlias +{ + return ProducerAlias::create([ + 'producer_id' => $producer->id, + 'name' => $name, + 'normalized_name' => NameNormalizer::normalize($name), + 'source' => $source, + ]); +} + +test('az árlista feldolgozó az alias-t is feloldja a gyártó lookup térképében', function () { + $active = makeProducer('Kőröstej Kft.'); + makeAlias($active, 'Kőröstej'); + + $lookup = callPrivate(app(PricelistFileProcessService::class), 'getProducerLookupMap'); + + expect($lookup[NameNormalizer::normalize('Kőröstej')] ?? null)->toBe($active->id); +}); + +test('az alias sosem írja felül élő gyártó nevét a lookup térképben', function () { + $winner = makeProducer('Danone'); + $other = makeProducer('Bonduelle'); + // Direkt ütköztetett alias-t szúrunk be a resolver megkerülésével, hogy a + // térképépítés defenzív viselkedését - nem csak az író oldali guardot - + // ellenőrizzük. + makeAlias($other, 'Danone'); + + $lookup = callPrivate(app(PricelistFileProcessService::class), 'getProducerLookupMap'); + + expect($lookup[NameNormalizer::normalize('Danone')])->toBe($winner->id); +}); + +test('az archivált gyártóhoz tartozó alias kimarad a feloldásból', function () { + $archived = makeProducer('Régi Név', DbStatusFieldEnum::archive); + makeAlias($archived, 'Régi Név'); + + $lookup = callPrivate(app(PricelistFileProcessService::class), 'getProducerLookupMap'); + + expect($lookup[NameNormalizer::normalize('Régi Név')] ?? null)->toBeNull(); +}); + +test('az assertNameAvailable dob, ha a név élő gyártóval ütközik', function () { + makeProducer('Danone'); + + expect(fn () => (new ProducerAliasResolver)->assertNameAvailable('danone ')) + ->toThrow(RuntimeException::class); +}); + +test('az assertNameAvailable dob, ha a név egy másik alias-szal ütközik', function () { + $producer = makeProducer('Kőröstej Kft.'); + $other = makeProducer('Bonduelle'); + makeAlias($producer, 'Kőröstej'); + + expect(fn () => (new ProducerAliasResolver)->assertNameAvailable('Kőröstej', $other->id)) + ->toThrow(RuntimeException::class); +}); + +test('az assertNameAvailable nem tekinti ütközésnek a gyártó saját nevét', function () { + $producer = makeProducer('Danone'); + + (new ProducerAliasResolver)->assertNameAvailable('Danone', $producer->id); + + expect(true)->toBeTrue(); +}); + +test('az assertNameAvailable nem dob valódi új névre', function () { + makeProducer('Danone'); + + (new ProducerAliasResolver)->assertNameAvailable('Bonduelle'); + + expect(true)->toBeTrue(); +});