632 lines
24 KiB
PHP
632 lines
24 KiB
PHP
<?php
|
|
namespace App\Console\Commands;
|
|
|
|
use App\Models\RubricaUniversale;
|
|
use Illuminate\Console\Command;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Schema;
|
|
|
|
class GesconQaRubricaLegamiCommand extends Command
|
|
{
|
|
protected $signature = 'gescon:qa-rubrica-legami
|
|
{--rubrica-id=* : Uno o piu ID rubrica da analizzare}
|
|
{--limit=50 : Numero massimo di record se non passi rubrica-id}
|
|
{--apply-safe : Applica solo fix non ambigui su riferimenti e rubrica_ruoli}';
|
|
|
|
protected $description = 'Analizza e, se richiesto, applica fix sicuri sui legami rubrica -> stabile -> unita -> rubrica_ruoli.';
|
|
|
|
public function handle(): int
|
|
{
|
|
foreach (['rubrica_universale', 'stabili', 'unita_immobiliari'] as $table) {
|
|
if (! Schema::hasTable($table)) {
|
|
$this->error('Tabella richiesta mancante: ' . $table);
|
|
return self::FAILURE;
|
|
}
|
|
}
|
|
|
|
$rubricaIds = array_values(array_filter(array_map(
|
|
fn($value): int => is_numeric($value) ? (int) $value : 0,
|
|
(array) $this->option('rubrica-id')
|
|
)));
|
|
|
|
$query = RubricaUniversale::query()
|
|
->where('categoria', 'condomino')
|
|
->orderByDesc('id');
|
|
|
|
if ($rubricaIds !== []) {
|
|
$query->whereIn('id', $rubricaIds);
|
|
} else {
|
|
$query->where(function ($inner): void {
|
|
$inner->whereNull('riferimento_stabile')
|
|
->orWhereNull('riferimento_unita');
|
|
});
|
|
}
|
|
|
|
$rows = $query->limit(max(1, min(500, (int) $this->option('limit'))))->get();
|
|
if ($rows->isEmpty()) {
|
|
$this->info('Nessun record rubrica da analizzare.');
|
|
return self::SUCCESS;
|
|
}
|
|
|
|
$applySafe = (bool) $this->option('apply-safe');
|
|
$updatedReferences = 0;
|
|
$createdRuoli = 0;
|
|
$ambiguous = 0;
|
|
$manualReview = 0;
|
|
|
|
foreach ($rows as $rubrica) {
|
|
$analysis = $this->analyzeRubrica($rubrica);
|
|
|
|
$this->line('');
|
|
$this->info('Rubrica #' . (int) $rubrica->id . ' - ' . $this->displayRubricaName($rubrica));
|
|
$this->line('Legacy: cod_stabile=' . ($analysis['legacy']['cod_stabile'] ?: '-') . ' | cod_cond=' . ($analysis['legacy']['cod_cond'] ?: '-') . ' | ruolo=' . ($analysis['legacy']['ruolo'] ?: '-'));
|
|
$this->line('Stabile candidato: ' . ($analysis['stabile_label'] ?: '-'));
|
|
$this->line('Ruoli esistenti: ' . count($analysis['existing_ruoli']));
|
|
$this->line('Persona match: ' . ($analysis['persona_summary'] !== '' ? $analysis['persona_summary'] : '-'));
|
|
|
|
if ($analysis['candidate_units'] === []) {
|
|
$this->warn('Nessuna unita candidata trovata.');
|
|
} else {
|
|
foreach ($analysis['candidate_units'] as $candidate) {
|
|
$this->line('- unita #' . $candidate['unit_id']
|
|
. ' [' . $candidate['source'] . '] '
|
|
. $candidate['unit_label']
|
|
. ' | ruolo=' . ($candidate['role_standard'] ?: '-')
|
|
. ' | fix-ruolo=' . ($candidate['safe_role_creation'] ? 'si' : 'no'));
|
|
}
|
|
}
|
|
|
|
if ($analysis['unique_unit'] === null && $analysis['candidate_units'] !== []) {
|
|
$ambiguous++;
|
|
$this->warn('Caso ambiguo: piu unita candidate o ruolo non sicuro.');
|
|
} elseif ($analysis['requires_manual_review']) {
|
|
$manualReview++;
|
|
$this->warn('Caso da revisione manuale: unita unica trovata, ma il ruolo strutturato non e abbastanza sicuro da creare rubrica_ruoli.');
|
|
}
|
|
|
|
if (! $applySafe) {
|
|
continue;
|
|
}
|
|
|
|
$applied = $this->applySafeFixes($rubrica, $analysis);
|
|
$updatedReferences += $applied['references_updated'];
|
|
$createdRuoli += $applied['ruoli_created'];
|
|
}
|
|
|
|
$this->line('');
|
|
$this->info('QA legami completato.');
|
|
$this->line('Record analizzati: ' . $rows->count());
|
|
$this->line('Casi ambigui: ' . $ambiguous);
|
|
$this->line('Casi da revisione manuale: ' . $manualReview);
|
|
if ($applySafe) {
|
|
$this->line('Riferimenti aggiornati: ' . $updatedReferences);
|
|
$this->line('Rubrica ruoli creati: ' . $createdRuoli);
|
|
}
|
|
|
|
return ($ambiguous > 0 || $manualReview > 0) ? self::INVALID : self::SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* @return array<string,mixed>
|
|
*/
|
|
private function analyzeRubrica(RubricaUniversale $rubrica): array
|
|
{
|
|
$legacy = $this->parseLegacyMeta((string) ($rubrica->note ?? ''));
|
|
$stabile = $this->resolveStabile($legacy['cod_stabile']);
|
|
$existingRuoli = Schema::hasTable('rubrica_ruoli')
|
|
? DB::table('rubrica_ruoli')->where('rubrica_id', (int) $rubrica->id)->get()->all()
|
|
: [];
|
|
|
|
$personaMatches = $this->findPersonaMatches($rubrica, $stabile['id']);
|
|
$candidateUnits = $this->mergeCandidates(
|
|
$this->collectLegacyUnitCandidates($stabile['id'], $legacy),
|
|
$this->collectPersonaRelationCandidates($personaMatches, $stabile['id']),
|
|
$this->collectImportUnitCandidates($rubrica, $stabile['id'], $legacy)
|
|
);
|
|
|
|
$uniqueUnit = count($candidateUnits) === 1 ? $candidateUnits[0] : null;
|
|
if ($uniqueUnit !== null && ($uniqueUnit['role_standard'] ?? null) === null) {
|
|
$uniqueUnit['role_standard'] = $this->mapRoleStandard($legacy['ruolo']);
|
|
}
|
|
if ($uniqueUnit !== null && ($uniqueUnit['role_standard'] ?? null) === null) {
|
|
$uniqueUnit = null;
|
|
}
|
|
|
|
$requiresManualReview = $uniqueUnit !== null
|
|
&& ! empty($stabile['id'])
|
|
&& ! $uniqueUnit['safe_role_creation']
|
|
&& count($existingRuoli) === 0;
|
|
|
|
return [
|
|
'legacy' => $legacy,
|
|
'stabile' => $stabile,
|
|
'stabile_label' => $this->buildStabileReference($stabile),
|
|
'existing_ruoli' => $existingRuoli,
|
|
'candidate_units' => $candidateUnits,
|
|
'unique_unit' => $uniqueUnit,
|
|
'persona_summary' => $this->summarizePersonas($personaMatches),
|
|
'requires_manual_review' => $requiresManualReview,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @return array{references_updated:int,ruoli_created:int}
|
|
*/
|
|
private function applySafeFixes(RubricaUniversale $rubrica, array $analysis): array
|
|
{
|
|
$referencesUpdated = 0;
|
|
$ruoliCreated = 0;
|
|
$stabile = $analysis['stabile'];
|
|
$uniqueUnit = $analysis['unique_unit'];
|
|
|
|
$dirty = false;
|
|
if (($rubrica->riferimento_stabile === null || trim((string) $rubrica->riferimento_stabile) === '') && ! empty($stabile['id'])) {
|
|
$rubrica->riferimento_stabile = $this->buildStabileReference($stabile);
|
|
$dirty = true;
|
|
}
|
|
|
|
if (($rubrica->riferimento_unita === null || trim((string) $rubrica->riferimento_unita) === '') && $uniqueUnit !== null) {
|
|
$rubrica->riferimento_unita = $uniqueUnit['unit_reference'];
|
|
$dirty = true;
|
|
}
|
|
|
|
if ($dirty) {
|
|
$rubrica->data_ultima_modifica = now();
|
|
$rubrica->save();
|
|
$referencesUpdated++;
|
|
}
|
|
|
|
if (
|
|
$uniqueUnit !== null
|
|
&& ! empty($stabile['id'])
|
|
&& $uniqueUnit['safe_role_creation']
|
|
&& ($uniqueUnit['role_standard'] ?? null) !== null
|
|
&& Schema::hasTable('rubrica_ruoli')
|
|
&& count($analysis['existing_ruoli']) === 0
|
|
) {
|
|
DB::table('rubrica_ruoli')->updateOrInsert(
|
|
[
|
|
'rubrica_id' => (int) $rubrica->id,
|
|
'stabile_id' => (int) $stabile['id'],
|
|
'unita_immobiliare_id' => (int) $uniqueUnit['unit_id'],
|
|
'ruolo_standard' => $uniqueUnit['role_standard'],
|
|
],
|
|
[
|
|
'is_attivo' => true,
|
|
'is_preferito' => true,
|
|
'meta' => json_encode([
|
|
'source' => $uniqueUnit['source'],
|
|
'created_by' => 'gescon:qa-rubrica-legami',
|
|
], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
|
|
'updated_at' => now(),
|
|
'created_at' => now(),
|
|
]
|
|
);
|
|
|
|
$ruoliCreated++;
|
|
}
|
|
|
|
return [
|
|
'references_updated' => $referencesUpdated,
|
|
'ruoli_created' => $ruoliCreated,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @return array{cod_stabile:?string,cod_cond:?string,ruolo:?string}
|
|
*/
|
|
private function parseLegacyMeta(string $note): array
|
|
{
|
|
$payload = [
|
|
'cod_stabile' => null,
|
|
'cod_cond' => null,
|
|
'ruolo' => null,
|
|
];
|
|
|
|
foreach (['cod_stabile', 'cod_cond', 'ruolo'] as $key) {
|
|
if (preg_match('/' . preg_quote($key, '/') . '=([^|\n\r]+)/i', $note, $matches) === 1) {
|
|
$payload[$key] = trim((string) ($matches[1] ?? '')) ?: null;
|
|
}
|
|
}
|
|
|
|
return $payload;
|
|
}
|
|
|
|
/**
|
|
* @return array{id:int|null,codice_stabile:?string,cod_stabile:?string,denominazione:?string}
|
|
*/
|
|
private function resolveStabile(?string $legacyCode): array
|
|
{
|
|
$blank = ['id' => null, 'codice_stabile' => null, 'cod_stabile' => null, 'denominazione' => null];
|
|
$code = trim((string) $legacyCode);
|
|
if ($code === '') {
|
|
return $blank;
|
|
}
|
|
|
|
$trimmed = ltrim($code, '0');
|
|
$row = DB::table('stabili')
|
|
->select(['id', 'codice_stabile', 'cod_stabile', 'denominazione'])
|
|
->where(function ($query) use ($code, $trimmed): void {
|
|
$query->where('codice_stabile', $code)
|
|
->orWhere('cod_stabile', $code);
|
|
|
|
if ($trimmed !== '' && $trimmed !== $code) {
|
|
$query->orWhere('codice_stabile', $trimmed)
|
|
->orWhere('cod_stabile', $trimmed);
|
|
}
|
|
})
|
|
->orderBy('id')
|
|
->first();
|
|
|
|
if (! $row) {
|
|
return $blank;
|
|
}
|
|
|
|
return [
|
|
'id' => (int) $row->id,
|
|
'codice_stabile' => $row->codice_stabile ? (string) $row->codice_stabile : null,
|
|
'cod_stabile' => $row->cod_stabile ? (string) $row->cod_stabile : null,
|
|
'denominazione' => $row->denominazione ? (string) $row->denominazione : null,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @return array<int,array<string,mixed>>
|
|
*/
|
|
private function collectLegacyUnitCandidates(?int $stabileId, array $legacy): array
|
|
{
|
|
if (! Schema::hasTable('unita_immobiliare_nominativi') || ! $stabileId || empty($legacy['cod_cond'])) {
|
|
return [];
|
|
}
|
|
|
|
$rows = DB::table('unita_immobiliare_nominativi as uin')
|
|
->join('unita_immobiliari as ui', 'ui.id', '=', 'uin.unita_immobiliare_id')
|
|
->where('uin.stabile_id', $stabileId)
|
|
->where('uin.legacy_cond_id', trim((string) $legacy['cod_cond']))
|
|
->select([
|
|
'ui.id as unit_id',
|
|
'ui.codice_unita',
|
|
'ui.denominazione',
|
|
'ui.scala',
|
|
'ui.interno',
|
|
'uin.ruolo',
|
|
])
|
|
->orderBy('ui.id')
|
|
->get();
|
|
|
|
$grouped = [];
|
|
foreach ($rows as $row) {
|
|
$unitId = (int) $row->unit_id;
|
|
$grouped[$unitId] ??= [
|
|
'unit_id' => $unitId,
|
|
'unit_label' => $this->buildUnitLabel($row),
|
|
'unit_reference' => $this->buildUnitReference($row),
|
|
'source' => 'legacy_local',
|
|
'role_tokens' => [],
|
|
'safe_role_creation' => true,
|
|
];
|
|
|
|
$roleToken = $this->mapLegacyRoleToken((string) ($row->ruolo ?? ''));
|
|
if ($roleToken !== null) {
|
|
$grouped[$unitId]['role_tokens'][$roleToken] = true;
|
|
}
|
|
}
|
|
|
|
return array_values(array_map(function (array $candidate) use ($legacy): array {
|
|
$roleStandard = $this->mapRoleStandard($legacy['ruolo']);
|
|
if ($roleStandard === null) {
|
|
$tokens = array_keys($candidate['role_tokens']);
|
|
$roleStandard = count($tokens) === 1 ? $tokens[0] : null;
|
|
}
|
|
|
|
unset($candidate['role_tokens']);
|
|
$candidate['role_standard'] = $roleStandard;
|
|
|
|
return $candidate;
|
|
}, $grouped));
|
|
}
|
|
|
|
/**
|
|
* @param array<int,array<string,mixed>> $personaMatches
|
|
* @return array<int,array<string,mixed>>
|
|
*/
|
|
private function collectPersonaRelationCandidates(array $personaMatches, ?int $stabileId): array
|
|
{
|
|
if (! Schema::hasTable('persone_unita_relazioni') || $personaMatches === []) {
|
|
return [];
|
|
}
|
|
|
|
$personaIds = array_values(array_unique(array_map(fn(array $row): int => (int) $row['id'], $personaMatches)));
|
|
$rows = DB::table('persone_unita_relazioni as pur')
|
|
->join('unita_immobiliari as ui', 'ui.id', '=', 'pur.unita_id')
|
|
->whereIn('pur.persona_id', $personaIds)
|
|
->when($stabileId, fn($query) => $query->where('ui.stabile_id', $stabileId))
|
|
->select([
|
|
'pur.persona_id',
|
|
'pur.tipo_relazione',
|
|
'ui.id as unit_id',
|
|
'ui.codice_unita',
|
|
'ui.denominazione',
|
|
'ui.scala',
|
|
'ui.interno',
|
|
])
|
|
->orderBy('ui.id')
|
|
->get();
|
|
|
|
$grouped = [];
|
|
foreach ($rows as $row) {
|
|
$unitId = (int) $row->unit_id;
|
|
$grouped[$unitId] ??= [
|
|
'unit_id' => $unitId,
|
|
'unit_label' => $this->buildUnitLabel($row),
|
|
'unit_reference' => $this->buildUnitReference($row),
|
|
'source' => 'persona_relazione',
|
|
'role_tokens' => [],
|
|
'safe_role_creation' => true,
|
|
];
|
|
|
|
$roleStandard = $this->mapRoleStandard((string) ($row->tipo_relazione ?? ''));
|
|
if ($roleStandard !== null) {
|
|
$grouped[$unitId]['role_tokens'][$roleStandard] = true;
|
|
}
|
|
}
|
|
|
|
return array_values(array_map(function (array $candidate): array {
|
|
$tokens = array_keys($candidate['role_tokens']);
|
|
unset($candidate['role_tokens']);
|
|
$candidate['role_standard'] = count($tokens) === 1 ? $tokens[0] : null;
|
|
|
|
return $candidate;
|
|
}, $grouped));
|
|
}
|
|
|
|
/**
|
|
* @return array<int,array<string,mixed>>
|
|
*/
|
|
private function collectImportUnitCandidates(RubricaUniversale $rubrica, ?int $stabileId, array $legacy): array
|
|
{
|
|
if (! $stabileId || empty($legacy['cod_stabile']) || empty($legacy['cod_cond']) || ! $this->hasGesconImportCondomin()) {
|
|
return [];
|
|
}
|
|
|
|
$rows = DB::connection('gescon_import')
|
|
->table('condomin')
|
|
->where('cod_stabile', trim((string) $legacy['cod_stabile']))
|
|
->where('cod_cond', trim((string) $legacy['cod_cond']))
|
|
->select(['nom_cond', 'scala', 'interno', 'proprietario', 'inquilino'])
|
|
->get();
|
|
|
|
$candidates = [];
|
|
foreach ($rows as $row) {
|
|
$unit = $this->resolveUnitFromImportRow($stabileId, [
|
|
'nom_cond' => (string) ($row->nom_cond ?? ''),
|
|
'scala' => (string) ($row->scala ?? ''),
|
|
'interno' => (string) ($row->interno ?? ''),
|
|
]);
|
|
|
|
if ($unit === null) {
|
|
continue;
|
|
}
|
|
|
|
$roleFromNote = $this->mapRoleStandard($legacy['ruolo']);
|
|
$candidates[] = [
|
|
'unit_id' => (int) $unit->unit_id,
|
|
'unit_label' => $this->buildUnitLabel($unit),
|
|
'unit_reference' => $this->buildUnitReference($unit),
|
|
'source' => 'gescon_import',
|
|
'role_standard' => $roleFromNote,
|
|
'safe_role_creation' => false,
|
|
];
|
|
}
|
|
|
|
return $candidates;
|
|
}
|
|
|
|
/**
|
|
* @return array<int,array<string,mixed>>
|
|
*/
|
|
private function findPersonaMatches(RubricaUniversale $rubrica, ?int $stabileId): array
|
|
{
|
|
if (! Schema::hasTable('persone')) {
|
|
return [];
|
|
}
|
|
|
|
$query = DB::table('persone')->select(['id', 'nome', 'cognome', 'ragione_sociale', 'codice_fiscale', 'email_principale', 'telefono_principale']);
|
|
|
|
$cf = trim((string) ($rubrica->codice_fiscale ?? ''));
|
|
if ($cf !== '') {
|
|
$rows = (clone $query)->where('codice_fiscale', $cf)->get();
|
|
if ($rows->isNotEmpty()) {
|
|
return $rows->map(fn($row) => (array) $row)->all();
|
|
}
|
|
}
|
|
|
|
$email = mb_strtolower(trim((string) ($rubrica->email ?? '')));
|
|
if ($email !== '') {
|
|
$rows = (clone $query)->whereRaw('LOWER(email_principale) = ?', [$email])->get();
|
|
if ($rows->isNotEmpty()) {
|
|
return $rows->map(fn($row) => (array) $row)->all();
|
|
}
|
|
}
|
|
|
|
$phone = $this->normalizeDigits((string) ($rubrica->telefono_cellulare ?: $rubrica->telefono_ufficio ?: ''));
|
|
if ($phone !== '') {
|
|
$rows = (clone $query)
|
|
->whereRaw("REPLACE(REPLACE(REPLACE(COALESCE(telefono_principale, ''), ' ', ''), '+', ''), '-', '') = ?", [$phone])
|
|
->get();
|
|
if ($rows->isNotEmpty()) {
|
|
return $rows->map(fn($row) => (array) $row)->all();
|
|
}
|
|
}
|
|
|
|
$ragioneSociale = $this->normalizeText((string) ($rubrica->ragione_sociale ?: $rubrica->nome_completo));
|
|
if ($ragioneSociale !== '') {
|
|
return (clone $query)
|
|
->whereRaw("UPPER(REGEXP_REPLACE(COALESCE(ragione_sociale, ''), '[^A-Z0-9]', '')) = ?", [$ragioneSociale])
|
|
->get()
|
|
->map(fn($row) => (array) $row)
|
|
->all();
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* @param array<int,array<string,mixed>> ...$candidateSets
|
|
* @return array<int,array<string,mixed>>
|
|
*/
|
|
private function mergeCandidates(array ...$candidateSets): array
|
|
{
|
|
$merged = [];
|
|
foreach ($candidateSets as $candidateSet) {
|
|
foreach ($candidateSet as $candidate) {
|
|
$unitId = (int) ($candidate['unit_id'] ?? 0);
|
|
if ($unitId <= 0) {
|
|
continue;
|
|
}
|
|
|
|
if (! isset($merged[$unitId])) {
|
|
$merged[$unitId] = $candidate;
|
|
continue;
|
|
}
|
|
|
|
$merged[$unitId]['source'] .= '+' . $candidate['source'];
|
|
$merged[$unitId]['safe_role_creation'] = (bool) $merged[$unitId]['safe_role_creation'] || (bool) $candidate['safe_role_creation'];
|
|
if (($merged[$unitId]['role_standard'] ?? null) === null && ($candidate['role_standard'] ?? null) !== null) {
|
|
$merged[$unitId]['role_standard'] = $candidate['role_standard'];
|
|
}
|
|
}
|
|
}
|
|
|
|
ksort($merged);
|
|
|
|
return array_values($merged);
|
|
}
|
|
|
|
private function resolveUnitFromImportRow(int $stabileId, array $row): ?object
|
|
{
|
|
$query = DB::table('unita_immobiliari')
|
|
->where('stabile_id', $stabileId)
|
|
->select(['id as unit_id', 'codice_unita', 'denominazione', 'scala', 'interno']);
|
|
|
|
$scala = trim((string) ($row['scala'] ?? ''));
|
|
$interno = trim((string) ($row['interno'] ?? ''));
|
|
|
|
if ($scala !== '' || $interno !== '') {
|
|
$strict = (clone $query)
|
|
->when($scala !== '', fn($inner) => $inner->where('scala', $scala))
|
|
->when($interno !== '', fn($inner) => $inner->where('interno', $interno))
|
|
->get();
|
|
if ($strict->count() === 1) {
|
|
return $strict->first();
|
|
}
|
|
}
|
|
|
|
$normalizedName = $this->normalizeText((string) ($row['nom_cond'] ?? ''));
|
|
if ($normalizedName === '') {
|
|
return null;
|
|
}
|
|
|
|
$matches = (clone $query)->get()->filter(function ($unit) use ($normalizedName): bool {
|
|
$haystack = $this->normalizeText((string) ($unit->denominazione ?? ''));
|
|
|
|
return $haystack !== '' && ($haystack === $normalizedName || str_contains($haystack, $normalizedName) || str_contains($normalizedName, $haystack));
|
|
})->values();
|
|
|
|
return $matches->count() === 1 ? $matches->first() : null;
|
|
}
|
|
|
|
private function hasGesconImportCondomin(): bool
|
|
{
|
|
try {
|
|
return Schema::connection('gescon_import')->hasTable('condomin');
|
|
} catch (\Throwable) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private function buildStabileReference(array $stabile): ?string
|
|
{
|
|
if (empty($stabile['id'])) {
|
|
return null;
|
|
}
|
|
|
|
$parts = array_values(array_filter([
|
|
trim((string) ($stabile['cod_stabile'] ?? '')),
|
|
trim((string) ($stabile['codice_stabile'] ?? '')),
|
|
trim((string) ($stabile['denominazione'] ?? '')),
|
|
]));
|
|
|
|
return $parts !== [] ? implode(' - ', $parts) : ('Stabile #' . (int) $stabile['id']);
|
|
}
|
|
|
|
private function buildUnitReference(object|array $row): string
|
|
{
|
|
$code = trim((string) data_get((array) $row, 'codice_unita', data_get($row, 'codice_unita', '')));
|
|
$label = trim((string) data_get((array) $row, 'denominazione', data_get($row, 'denominazione', '')));
|
|
|
|
return trim($code . ($label !== '' ? ' - ' . $label : ''));
|
|
}
|
|
|
|
private function buildUnitLabel(object|array $row): string
|
|
{
|
|
$code = trim((string) data_get((array) $row, 'codice_unita', data_get($row, 'codice_unita', '')));
|
|
$scala = trim((string) data_get((array) $row, 'scala', data_get($row, 'scala', '')));
|
|
$interno = trim((string) data_get((array) $row, 'interno', data_get($row, 'interno', '')));
|
|
$denominazione = trim((string) data_get((array) $row, 'denominazione', data_get($row, 'denominazione', '')));
|
|
|
|
$bits = array_values(array_filter([$code, $scala, $interno, $denominazione]));
|
|
|
|
return implode(' / ', $bits);
|
|
}
|
|
|
|
private function mapRoleStandard(?string $value): ?string
|
|
{
|
|
$normalized = strtolower(trim((string) $value));
|
|
|
|
return match ($normalized) {
|
|
'c', 'condomino', 'proprietario', 'comproprietario', 'nudo_proprietario', 'usufruttuario', 'titolare' => 'condomino',
|
|
'i', 'inquilino', 'conduttore', 'locatario' => 'inquilino',
|
|
default => null,
|
|
};
|
|
}
|
|
|
|
private function mapLegacyRoleToken(string $value): ?string
|
|
{
|
|
return $this->mapRoleStandard($value);
|
|
}
|
|
|
|
private function displayRubricaName(RubricaUniversale $rubrica): string
|
|
{
|
|
return trim((string) ($rubrica->nome_completo ?: $rubrica->ragione_sociale ?: ('Rubrica #' . $rubrica->id)));
|
|
}
|
|
|
|
/**
|
|
* @param array<int,array<string,mixed>> $personaMatches
|
|
*/
|
|
private function summarizePersonas(array $personaMatches): string
|
|
{
|
|
if ($personaMatches === []) {
|
|
return '';
|
|
}
|
|
|
|
return implode(', ', array_map(function (array $row): string {
|
|
$label = trim((string) (($row['ragione_sociale'] ?? '') ?: trim((string) (($row['cognome'] ?? '') . ' ' . ($row['nome'] ?? '')))));
|
|
|
|
return '#' . (int) $row['id'] . ' ' . ($label !== '' ? $label : 'persona');
|
|
}, $personaMatches));
|
|
}
|
|
|
|
private function normalizeDigits(string $value): string
|
|
{
|
|
return preg_replace('/\D+/', '', $value) ?: '';
|
|
}
|
|
|
|
private function normalizeText(string $value): string
|
|
{
|
|
$upper = mb_strtoupper(trim($value));
|
|
$normalized = preg_replace('/[^A-Z0-9]+/u', '', $upper);
|
|
|
|
return is_string($normalized) ? $normalized : '';
|
|
}
|
|
} |