redmine

app/Console/Commands/ImportaRedmine.php

@@ -13,34 +13,26 @@ use Throwable;
 class ImportaRedmine extends Command
 {
     protected $signature = 'redmine:import
-                            {project? : ID o identifier del progetto Redmine}
-                            {azienda? : ID, ragione sociale o email dell\'azienda locale}
+                            {project? : ID o identifier del progetto Redmine (se omesso, importa tutti i progetti)}
+                            {azienda? : ID, ragione sociale o email dell\'azienda locale (se omesso, viene creata/riusata dal progetto)}
                             {--list-projects : Elenca i progetti visibili in Redmine}
                             {--url= : URL Redmine (override REDMINE_URL)}
                             {--api-key= : API key (override REDMINE_API_KEY)}
                             {--dry-run : Mostra cosa verrebbe importato, senza scrivere}
                             {--update : Aggiorna segnalazioni già importate da questo progetto}
-                            {--con-sottoprogetti : Include anche i sotto-progetti}
+                            {--con-sottoprogetti : Include anche i sotto-progetti (solo import di un singolo progetto)}
                             {--no-attachments : Non scaricare gli allegati}
                             {--no-tempi : Non importare i time entry}
                             {--crea-utenti : Crea anche gli autori di journal/tempi se non esistono (contatti e assegnatari vengono sempre creati)}
                             {--user-fallback= : ID utente locale se non c\'è match}
                             {--tariffa= : €/ora per calcolare il costo dai tempi}
                             {--contratto= : ID del contratto servizio da assegnare alle segnalazioni}
-                            {--limit= : Importa al massimo N issue}';
+                            {--limit= : Importa al massimo N issue (per progetto)}';
 
-    protected $description = 'Importa issue, tempi, costi e allegati da un progetto Redmine 6.x verso un\'azienda locale';
+    protected $description = 'Importa issue, tempi, costi e allegati da Redmine 6.x. Senza progetto importa tutti i progetti e crea le aziende mancanti.';
 
     public function handle(): int
     {
-        if (! $this->option('list-projects') && (! $this->argument('project') || ! $this->argument('azienda'))) {
-            $this->error('Specifica progetto Redmine e azienda locale, oppure usa --list-projects.');
-            $this->line('Esempio: php artisan redmine:import NOME_PROGETTO 12');
-            $this->line('         php artisan redmine:import 42 "ElephanTech" --dry-run');
-
-            return self::INVALID;
-        }
-
         try {
             $client = RedmineClient::fromConfig(
                 $this->option('url') ?: null,
@@ -59,9 +51,20 @@ class ImportaRedmine extends Command
         $projectArg = $this->argument('project');
         $aziendaArg = $this->argument('azienda');
 
+        if ($projectArg) {
+            return $this->importSingleProject($client, (string) $projectArg, $aziendaArg ? (string) $aziendaArg : null);
+        }
+
+        if ($aziendaArg) {
+            $this->warn('Senza progetto l\'azienda indicata viene ignorata: ogni progetto Redmine ha la propria azienda.');
+        }
+
+        return $this->importAllProjects($client);
+    }
+
+    protected function importSingleProject(RedmineClient $client, string $projectArg, ?string $aziendaArg): int
+    {
         try {
-            $azienda = $this->resolveAzienda((string) $aziendaArg);
-            $contratto = $this->resolveContratto($this->option('contratto'), $azienda);
             $project = $client->project($projectArg);
         } catch (Throwable $e) {
             $this->error($e->getMessage());
@@ -75,24 +78,185 @@ class ImportaRedmine extends Command
             return self::FAILURE;
         }
 
-        $this->info('Redmine:  '.$client->baseUrl());
-        $this->info('Progetto: #'.$project['id'].' '.$project['name'].' ('.$project['identifier'].')');
-        $this->info('Azienda:  #'.$azienda->id.' '.($azienda->ragione_sociale ?: $azienda->nome));
-        if ($contratto) {
-            $this->info('Contratto: #'.$contratto->id.' '.$contratto->label);
+        try {
+            $azienda = $aziendaArg !== null
+                ? $this->resolveAzienda($aziendaArg)
+                : $this->matchAziendaForProject(
+                    trim((string) ($project['identifier'] ?? '')),
+                    trim((string) ($project['name'] ?? $project['identifier'] ?? '')),
+                );
+            $contratto = ($aziendaArg !== null && $azienda)
+                ? $this->resolveContratto($this->option('contratto'), $azienda)
+                : null;
+        } catch (Throwable $e) {
+            $this->error($e->getMessage());
+
+            return self::FAILURE;
+        }
+
+        if ($aziendaArg === null && $this->option('contratto')) {
+            $this->warn('--contratto è ignorato se l\'azienda non è indicata esplicitamente.');
+        }
+
+        $this->printHeader($client, $project, $azienda, $contratto);
+
+        if (! $this->option('no-interaction') && ! $this->confirm('Procedo con l\'import?', true)) {
+            $this->comment('Annullato.');
+
+            return self::SUCCESS;
+        }
+
+        if ($azienda === null) {
+            try {
+                $azienda = $this->findOrCreateAzienda($project);
+            } catch (Throwable $e) {
+                $this->error($e->getMessage());
+
+                return self::FAILURE;
+            }
+        } else {
+            $this->rememberRedmineProject($azienda, $project);
+        }
+
+        $result = $this->runImport($client, $project, $azienda, $contratto?->id, (bool) $this->option('con-sottoprogetti'));
+        $this->printStats($result['stats']);
+
+        return $result['ok'] ? self::SUCCESS : self::FAILURE;
+    }
+
+    protected function importAllProjects(RedmineClient $client): int
+    {
+        try {
+            $projects = $client->projects();
+        } catch (Throwable $e) {
+            $this->error($e->getMessage());
+
+            return self::FAILURE;
         }
+
+        if ($projects === []) {
+            $this->warn('Nessun progetto visibile su '.$client->baseUrl());
+
+            return self::SUCCESS;
+        }
+
+        if ($this->option('con-sottoprogetti')) {
+            $this->warn('--con-sottoprogetti è ignorato nell\'import di tutti i progetti: ogni progetto (anche i sotto-progetti) viene importato nella propria azienda.');
+        }
+        if ($this->option('contratto')) {
+            $this->warn('--contratto è ignorato nell\'import di tutti i progetti.');
+        }
+
+        $preview = [];
+        $jobs = [];
+        foreach ($projects as $project) {
+            if (empty($project['id'])) {
+                continue;
+            }
+            $identifier = trim((string) ($project['identifier'] ?? ''));
+            $name = trim((string) ($project['name'] ?? $identifier));
+            try {
+                $azienda = $this->matchAziendaForProject($identifier, $name);
+            } catch (Throwable $e) {
+                $this->error('#'.($project['id'] ?? '?').' '.($project['name'] ?? '').': '.$e->getMessage());
+
+                return self::FAILURE;
+            }
+            $jobs[] = ['project' => $project, 'azienda' => $azienda];
+            $preview[] = [
+                $project['id'] ?? '',
+                $project['identifier'] ?? '',
+                $project['name'] ?? '',
+                $azienda?->id ? '#'.$azienda->id : '—',
+                $azienda ? ($azienda->ragione_sociale ?: $azienda->nome) : $name,
+                $azienda ? 'esistente' : 'da creare',
+            ];
+        }
+
+        $this->info('Redmine: '.$client->baseUrl());
+        $this->info('Progetti da importare: '.count($jobs));
         if ($this->option('dry-run')) {
             $this->warn('Modalità dry-run: nessuna scrittura sul database.');
         }
+        $this->table(['ID', 'Identifier', 'Progetto', 'Azienda ID', 'Azienda', 'Stato'], $preview);
 
-        if (! $this->option('no-interaction') && ! $this->confirm('Procedo con l\'import?', true)) {
+        if (! $this->option('no-interaction') && ! $this->confirm('Procedo con l\'import di '.count($jobs).' progetti?', true)) {
             $this->comment('Annullato.');
 
             return self::SUCCESS;
         }
 
+        $totals = $this->emptyStats();
+        $hadErrors = false;
+        $projectRows = [];
+
+        foreach ($jobs as $index => $job) {
+            $project = $job['project'];
+            try {
+                $azienda = $job['azienda'] ?? $this->findOrCreateAzienda($project);
+                if ($job['azienda']) {
+                    $this->rememberRedmineProject($azienda, $project);
+                }
+            } catch (Throwable $e) {
+                $this->error($e->getMessage());
+                $hadErrors = true;
+                $projectRows[] = [
+                    $project['identifier'] ?? $project['id'],
+                    0, 0, 0, 0, 'errore azienda',
+                ];
+                continue;
+            }
+            $this->newLine();
+            $this->info(sprintf(
+                '[%d/%d] #%s %s → azienda #%s %s',
+                $index + 1,
+                count($jobs),
+                $project['id'],
+                $project['name'] ?? $project['identifier'],
+                $azienda->id ?: '—',
+                $azienda->ragione_sociale ?: $azienda->nome,
+            ));
+
+            $result = $this->runImport($client, $project, $azienda, null, false);
+            $stats = $result['stats'];
+            $this->mergeStats($totals, $stats);
+            if (! $result['ok']) {
+                $hadErrors = true;
+            }
+            $projectRows[] = [
+                $project['identifier'] ?? $project['id'],
+                $stats['issues'],
+                $stats['created'],
+                $stats['updated'],
+                $stats['skipped'],
+                $stats['errors'] === [] ? 'ok' : count($stats['errors']).' errori',
+            ];
+        }
+
+        $this->newLine();
+        $this->info('Riepilogo per progetto');
+        $this->table(['Progetto', 'Issue', 'Create', 'Aggiornate', 'Saltate', 'Esito'], $projectRows);
+        $this->info('Totale');
+        $this->printStats($totals);
+
+        return $hadErrors || $totals['errors'] !== [] ? self::FAILURE : self::SUCCESS;
+    }
+
+    /**
+     * @param  array<string, mixed>  $project
+     * @return array{ok: bool, stats: array<string, mixed>}
+     */
+    protected function runImport(
+        RedmineClient $client,
+        array $project,
+        Azienda $azienda,
+        ?int $contrattoServizioId,
+        bool $includeSubprojects,
+    ): array {
         $tariffa = $this->option('tariffa');
         $limit = $this->option('limit');
+        $empty = $this->emptyStats();
+        $empty['project'] = $project;
 
         $service = new RedmineImportService(
             client: $client,
@@ -104,7 +268,7 @@ class ImportaRedmine extends Command
             creaUtenti: (bool) $this->option('crea-utenti'),
             hourlyRate: $tariffa !== null && $tariffa !== '' ? (float) $tariffa : null,
             userFallbackId: $this->option('user-fallback') ? (int) $this->option('user-fallback') : null,
-            contrattoServizioId: $contratto?->id,
+            contrattoServizioId: $contrattoServizioId,
             onProgress: function (int $current, int $total, int $issueId) {
                 if ($current === 1) {
                     $this->output->progressStart($total);
@@ -119,7 +283,7 @@ class ImportaRedmine extends Command
         try {
             $stats = $service->import(
                 $project['id'],
-                (bool) $this->option('con-sottoprogetti'),
+                $includeSubprojects,
                 $limit !== null && $limit !== '' ? (int) $limit : null,
             );
         } catch (Throwable $e) {
@@ -127,39 +291,215 @@ class ImportaRedmine extends Command
                 $this->error($e->getTraceAsString());
             }
             $this->error($e->getMessage());
+            $empty['errors'][] = $e->getMessage();
 
-            return self::FAILURE;
+            return ['ok' => false, 'stats' => $empty];
+        }
+
+        return ['ok' => $stats['errors'] === [], 'stats' => $stats];
+    }
+
+    /**
+     * @param  array<string, mixed>  $project
+     */
+    protected function findOrCreateAzienda(array $project): Azienda
+    {
+        $identifier = trim((string) ($project['identifier'] ?? ''));
+        $name = trim((string) ($project['name'] ?? $identifier));
+        if ($name === '') {
+            throw new RuntimeException('Progetto Redmine #'.($project['id'] ?? '?').' senza nome né identifier.');
         }
 
+        $existing = $this->matchAziendaForProject($identifier, $name);
+        if ($existing) {
+            $this->rememberRedmineProject($existing, $project);
+
+            return $existing;
+        }
+
+        if ($this->option('dry-run')) {
+            $azienda = new Azienda();
+            $azienda->ragione_sociale = $name;
+            $azienda->nome = $name;
+            $azienda->note = $this->redmineNote($project);
+
+            return $azienda;
+        }
+
+        $azienda = new Azienda();
+        $azienda->ragione_sociale = $name;
+        $azienda->nome = $name;
+        $azienda->note = $this->redmineNote($project);
+        $azienda->save();
+
+        $this->info('  Azienda creata: #'.$azienda->id.' '.$name.' ('.$identifier.')');
+
+        return $azienda;
+    }
+
+    protected function matchAziendaForProject(string $identifier, string $name): ?Azienda
+    {
+        if ($identifier !== '') {
+            $byToken = Azienda::query()
+                ->where('note', 'like', '%'.$this->redmineIdentifierToken($identifier).'%')
+                ->first();
+            if ($byToken) {
+                return $byToken;
+            }
+        }
+
+        $matches = Azienda::query()
+            ->where(function ($q) use ($name, $identifier) {
+                $q->where('ragione_sociale', $name)
+                    ->orWhere('nome', $name);
+                if ($identifier !== '' && $identifier !== $name) {
+                    $q->orWhere('ragione_sociale', $identifier)
+                        ->orWhere('nome', $identifier);
+                }
+            })
+            ->get();
+
+        if ($matches->count() === 1) {
+            return $matches->first();
+        }
+
+        if ($matches->count() > 1) {
+            $elenco = $matches->map(fn (Azienda $a) => '#'.$a->id.' '.($a->ragione_sociale ?: $a->nome))->implode(', ');
+            throw new RuntimeException('Azienda ambigua per il progetto "'.$name.'". Specifica l\'ID. Trovate: '.$elenco);
+        }
+
+        return null;
+    }
+
+    /**
+     * @param  array<string, mixed>  $project
+     */
+    protected function rememberRedmineProject(Azienda $azienda, array $project): void
+    {
+        $token = $this->redmineIdentifierToken((string) ($project['identifier'] ?? ''));
+        if ($token === '' || str_contains((string) $azienda->note, $token)) {
+            return;
+        }
+        if ($this->option('dry-run') || ! $azienda->exists) {
+            return;
+        }
+
+        $note = trim((string) $azienda->note);
+        $azienda->note = ($note !== '' ? $note."\n" : '').$this->redmineNote($project);
+        $azienda->save();
+    }
+
+    /**
+     * @param  array<string, mixed>  $project
+     */
+    protected function redmineNote(array $project): string
+    {
+        $identifier = (string) ($project['identifier'] ?? '');
+
+        return sprintf(
+            '[redmine-import] project_id=%s %s',
+            $project['id'] ?? '',
+            $this->redmineIdentifierToken($identifier),
+        );
+    }
+
+    protected function redmineIdentifierToken(string $identifier): string
+    {
+        $identifier = trim($identifier);
+
+        return $identifier === '' ? '' : 'identifier="'.$identifier.'"';
+    }
+
+    /**
+     * @param  array<string, mixed>  $project
+     */
+    protected function printHeader(RedmineClient $client, array $project, ?Azienda $azienda, ?ContrattoServizio $contratto): void
+    {
+        $this->info('Redmine:  '.$client->baseUrl());
+        $this->info('Progetto: #'.$project['id'].' '.$project['name'].' ('.$project['identifier'].')');
+        if ($azienda) {
+            $this->info('Azienda:  #'.$azienda->id.' '.($azienda->ragione_sociale ?: $azienda->nome));
+        } else {
+            $this->info('Azienda:  verrà creata da «'.($project['name'] ?? $project['identifier']).'»');
+        }
+        if ($contratto) {
+            $this->info('Contratto: #'.$contratto->id.' '.$contratto->label);
+        }
+        if ($this->option('dry-run')) {
+            $this->warn('Modalità dry-run: nessuna scrittura sul database.');
+        }
+    }
+
+    /**
+     * @param  array<string, mixed>  $stats
+     */
+    protected function printStats(array $stats): void
+    {
         $this->newLine();
         $this->table(
             ['Voce', 'Valore'],
             [
-                ['Issue Redmine', $stats['issues']],
-                ['Segnalazioni create', $stats['created']],
-                ['Segnalazioni aggiornate', $stats['updated']],
-                ['Segnalazioni saltate (già importate)', $stats['skipped']],
-                ['Annotazioni', $stats['annotazioni']],
-                ['Time entry', $stats['tempi']],
-                ['Costi', $stats['costi']],
-                ['Allegati', $stats['allegati']],
-                ['Todo / checklist', $stats['todos']],
-                ['Utenti creati', $stats['utenti_creati']],
+                ['Issue Redmine', $stats['issues'] ?? 0],
+                ['Segnalazioni create', $stats['created'] ?? 0],
+                ['Segnalazioni aggiornate', $stats['updated'] ?? 0],
+                ['Segnalazioni saltate (già importate)', $stats['skipped'] ?? 0],
+                ['Annotazioni', $stats['annotazioni'] ?? 0],
+                ['Time entry', $stats['tempi'] ?? 0],
+                ['Costi', $stats['costi'] ?? 0],
+                ['Allegati', $stats['allegati'] ?? 0],
+                ['Todo / checklist', $stats['todos'] ?? 0],
+                ['Utenti creati', $stats['utenti_creati'] ?? 0],
             ],
         );
 
-        foreach ($stats['warnings'] as $warning) {
+        foreach ($stats['warnings'] ?? [] as $warning) {
             $this->warn($warning);
         }
-        foreach ($stats['errors'] as $error) {
+        foreach ($stats['errors'] ?? [] as $error) {
             $this->error($error);
         }
 
-        if ($stats['skipped'] > 0 && ! $this->option('update')) {
+        if (($stats['skipped'] ?? 0) > 0 && ! $this->option('update')) {
             $this->comment('Le issue già importate sono state saltate. Usa --update per riallinearle.');
         }
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    protected function emptyStats(): array
+    {
+        return [
+            'issues' => 0,
+            'created' => 0,
+            'updated' => 0,
+            'skipped' => 0,
+            'annotazioni' => 0,
+            'tempi' => 0,
+            'costi' => 0,
+            'allegati' => 0,
+            'todos' => 0,
+            'utenti_creati' => 0,
+            'warnings' => [],
+            'errors' => [],
+        ];
+    }
 
-        return $stats['errors'] === [] ? self::SUCCESS : self::FAILURE;
+    /**
+     * @param  array<string, mixed>  $totals
+     * @param  array<string, mixed>  $stats
+     */
+    protected function mergeStats(array &$totals, array $stats): void
+    {
+        foreach (['issues', 'created', 'updated', 'skipped', 'annotazioni', 'tempi', 'costi', 'allegati', 'todos', 'utenti_creati'] as $key) {
+            $totals[$key] += (int) ($stats[$key] ?? 0);
+        }
+        foreach ($stats['warnings'] ?? [] as $warning) {
+            $totals['warnings'][] = $warning;
+        }
+        foreach ($stats['errors'] ?? [] as $error) {
+            $totals['errors'][] = $error;
+        }
     }
 
     protected function listProjects(RedmineClient $client): int
@@ -185,7 +525,9 @@ class ImportaRedmine extends Command
         }
 
         $this->table(['ID', 'Identifier', 'Nome', 'Stato'], $rows);
-        $this->comment('Usa l\'ID o l\'identifier come primo argomento di redmine:import.');
+        $this->comment('php artisan redmine:import                 importa tutti i progetti e crea le aziende');
+        $this->comment('php artisan redmine:import IDENTIFIER     importa un progetto (crea l\'azienda se manca)');
+        $this->comment('php artisan redmine:import IDENTIFIER 12  importa un progetto verso un\'azienda esistente');
 
         return self::SUCCESS;
     }