redmine

GestioneManutenzioni.skipper

           <property name="type" value="boolean"/>
         </element>
       </revision>
+      <revision uuid="7ae513b6-1349-4950-a0a7-3409bd0a7f87" date="2026-09-08 09:52:42.989062" exportable="true">
+        <element action="add" uuid="8b114aab-e736-49f0-a36f-c9a9c14253ba" parent-uuid="b21d156e-828b-49fe-87a8-659eb8411896" sibling-uuid="330da781-7ebb-4a50-b6fd-b626f954735f" type="field">
+          <property name="name" value="cc"/>
+          <property name="type" value="json"/>
+        </element>
+        <element action="add" uuid="04bc48b2-88ce-462f-920f-01ade337f877" parent-uuid="b21d156e-828b-49fe-87a8-659eb8411896" sibling-uuid="8b114aab-e736-49f0-a36f-c9a9c14253ba" type="field">
+          <property name="name" value="bcc"/>
+          <property name="type" value="json"/>
+        </element>
+        <element action="reorder" uuid="91880b18-1a17-4b31-85e5-61ae81e6aba2" parent-uuid="b21d156e-828b-49fe-87a8-659eb8411896" sibling-uuid="04bc48b2-88ce-462f-920f-01ade337f877" previous-sibling-uuid="330da781-7ebb-4a50-b6fd-b626f954735f" type="field" helper="true"/>
+      </revision>
     </migrations>
   </module>
   <visual-data>

app/Console/Commands/ImportaRedmine.php

                             {--tariffa= : €/ora per calcolare il costo dai tempi}
                             {--contratto= : ID del contratto servizio da assegnare alle segnalazioni}
                             {--limit= : Importa al massimo N issue (per progetto)}
-                            {--sync-cc : Aggiorna solo CC/CCN dalle ticket Helpdesk, senza reimportare le issue}';
+                            {--sync-cc : Aggiorna solo CC/CCN dalle ticket Helpdesk, senza reimportare le issue}
+                            {--restore-updated-at : Riallinea «Ultimo aggiornamento» (updated_at) dall\'ultima annotazione/journal, senza reimportare}';
 
     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('restore-updated-at')) {
+            return $this->restoreUpdatedAt();
+        }
+
         try {
             $client = RedmineClient::fromConfig(
                 $this->option('url') ?: null,
         return self::SUCCESS;
     }
 
+    protected function restoreUpdatedAt(): int
+    {
+        $limit = $this->option('limit');
+        $this->info('Riallineo «Ultimo aggiornamento» delle segnalazioni Redmine dall\'ultima annotazione/journal.');
+        $this->comment('Non chiama Redmine e non tocca CC/CCN: ripristina updated_at come all\'import originale.');
+        if ($this->option('dry-run')) {
+            $this->warn('Modalità dry-run: nessuna scrittura sul database.');
+        }
+
+        try {
+            $stats = RedmineImportService::restoreUpdatedAt(
+                (bool) $this->option('dry-run'),
+                $limit !== null && $limit !== '' ? (int) $limit : null,
+                function (int $current, int $total) {
+                    if ($current === 1) {
+                        $this->output->progressStart($total);
+                    }
+                    $this->output->progressAdvance();
+                    if ($current === $total) {
+                        $this->output->progressFinish();
+                    }
+                },
+            );
+        } catch (Throwable $e) {
+            $this->error($e->getMessage());
+
+            return self::FAILURE;
+        }
+
+        $this->newLine();
+        $this->table(
+            ['Voce', 'Valore'],
+            [
+                ['Segnalazioni Redmine', $stats['tickets']],
+                ['updated_at riallineati', $stats['updated']],
+                ['Già allineati', $stats['unchanged']],
+            ],
+        );
+
+        return self::SUCCESS;
+    }
+
     /**
      * @param  array<string, mixed>  $stats
      */
         $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');
+        $this->comment('php artisan redmine:import --restore-updated-at  riallinea «Ultimo aggiornamento» dalle annotazioni');
 
         return self::SUCCESS;
     }

app/Services/Redmine/RedmineImportService.php

 
             $this->stampSegnalazioneFromLastAnnotazione(
                 $segnalazione,
-                $this->parseDate(data_get($issue, 'created_on')) ?? $segnalazione->created_at,
+                self::parseDate(data_get($issue, 'created_on')) ?? $segnalazione->created_at,
             );
 
             $this->segnalazioniByIssueId[(int) $issue['id']] = $segnalazione;
             $timeStats = $this->importTimeEntries($segnalazione, $entries, false);
             $this->stampSegnalazioneFromLastAnnotazione(
                 $segnalazione,
-                $this->parseDate(data_get($fakeIssue, 'created_on')) ?? $segnalazione->created_at,
+                self::parseDate(data_get($fakeIssue, 'created_on')) ?? $segnalazione->created_at,
             );
             $this->segnalazioniByIssueId[$syntheticId] = $segnalazione;
 
     {
         $opener = $this->resolveIssueOpener($issue);
         $assignee = $this->resolveUser(data_get($issue, 'assigned_to'), forceCreate: true, asCliente: false);
-        $created = $this->parseDate(data_get($issue, 'created_on')) ?? now();
+        $created = self::parseDate(data_get($issue, 'created_on')) ?? now();
         $issueId = (int) ($issue['id'] ?? 0);
 
         if ($issueId > 0) {
 
         $html = $this->descriptionHtml($issue);
         $author = $this->resolveUser(data_get($issue, 'author'));
-        $created = $this->parseDate(data_get($issue, 'created_on')) ?? $segnalazione->created_at;
+        $created = self::parseDate(data_get($issue, 'created_on')) ?? $segnalazione->created_at;
 
         $createdNow = false;
         if (! $annotazione) {
             }
 
             $user = $this->resolveUser(data_get($journal, 'user'));
-            $created = $this->parseDate(data_get($journal, 'created_on')) ?? now();
+            $created = self::parseDate(data_get($journal, 'created_on')) ?? now();
 
             if ($statusChange !== null) {
                 $this->recordStatusChangeAudit(
             $annotazione->text = $html;
             $annotazione->riservata = $isPrivateIssue || (bool) ($journal['private_notes'] ?? false);
             $annotazione->save();
-            $this->stampDates($annotazione, $created, $this->parseDate(data_get($journal, 'updated_on')) ?? $created);
+            $this->stampDates($annotazione, $created, self::parseDate(data_get($journal, 'updated_on')) ?? $created);
 
             $map[(string) $journalId] = $annotazione->id;
             if ($createdNow) {
             }
 
             $user = $this->resolveUser(data_get($entry, 'user'));
-            $spentOn = $this->parseDate(data_get($entry, 'spent_on'))
-                ?? $this->parseDate(data_get($entry, 'created_on'))
+            $spentOn = self::parseDate(data_get($entry, 'spent_on'))
+                ?? self::parseDate(data_get($entry, 'created_on'))
                 ?? now();
-            $created = $this->parseDate(data_get($entry, 'created_on')) ?? $spentOn;
+            $created = self::parseDate(data_get($entry, 'created_on')) ?? $spentOn;
 
             $comment = trim((string) ($entry['comments'] ?? ''));
             $activity = (string) data_get($entry, 'activity.name', '');
                 : null;
             $annotazione->riservata = $riservata;
             $annotazione->save();
-            $this->stampDates($annotazione, $created, $this->parseDate(data_get($entry, 'updated_on')) ?? $created);
+            $this->stampDates($annotazione, $created, self::parseDate(data_get($entry, 'updated_on')) ?? $created);
 
             $map[(string) $entryId] = $annotazione->id;
             $tempi++;
 
         $annotazioni = 0;
         $costi = 0;
-        $createdAt = $this->parseDate(data_get($issue, 'created_on')) ?? $segnalazione->created_at;
+        $createdAt = self::parseDate(data_get($issue, 'created_on')) ?? $segnalazione->created_at;
         $author = $this->resolveUser(data_get($issue, 'author'));
 
         foreach ($items as $item) {
             $allegato->path_file = $path;
             $allegato->save();
 
-            $created = $this->parseDate(data_get($attachment, 'created_on'));
+            $created = self::parseDate(data_get($attachment, 'created_on'));
             if ($created) {
                 $allegato->timestamps = false;
                 $allegato->created_at = $created;
             $todo->public = true;
             $done = (bool) ($item['is_done'] ?? $item['done'] ?? false);
             if ($done && ! $todo->completato_at) {
-                $todo->completato_at = $this->parseDate(data_get($issue, 'updated_on')) ?? now();
+                $todo->completato_at = self::parseDate(data_get($issue, 'updated_on')) ?? now();
             }
             if (! $done) {
                 $todo->completato_at = null;
             if ($beforeCc === $afterCc && $afterCc === []) {
                 $stats['empty']++;
                 if (! $dryRun && $segnalazione->isDirty('meta')) {
-                    Segnalazione::withoutAuditing(function () use ($segnalazione) {
-                        $segnalazione->save();
-                    });
+                    self::saveWithoutTouchingTimestamps($segnalazione);
                 }
                 continue;
             }
                 continue;
             }
 
-            Segnalazione::withoutAuditing(function () use ($segnalazione) {
-                $segnalazione->save();
-            });
+            self::saveWithoutTouchingTimestamps($segnalazione);
         }
 
         return $stats;
     }
 
+    /**
+     * Riallinea updated_at delle segnalazioni importate da Redmine
+     * (ultima annotazione / journal), senza toccare CC né reimportare le issue.
+     *
+     * @return array{tickets:int, updated:int, unchanged:int}
+     */
+    public static function restoreUpdatedAt(bool $dryRun = false, ?int $limit = null, ?callable $onProgress = null): array
+    {
+        $query = Segnalazione::query()->where('origine', 'redmine')->orderBy('id');
+        if ($limit !== null) {
+            $query->limit(max(0, $limit));
+        }
+        $segnalazioni = $query->get();
+        $stats = [
+            'tickets' => $segnalazioni->count(),
+            'updated' => 0,
+            'unchanged' => 0,
+        ];
+        $total = $segnalazioni->count();
+        $current = 0;
+
+        foreach ($segnalazioni as $segnalazione) {
+            $current++;
+            if ($onProgress) {
+                $onProgress($current, $total, (int) $segnalazione->id);
+            }
+
+            $restored = self::lastActivityAt($segnalazione) ?? $segnalazione->created_at;
+            if (! $restored) {
+                $stats['unchanged']++;
+                continue;
+            }
+
+            $currentTs = $segnalazione->updated_at?->getTimestamp();
+            if ($currentTs === $restored->getTimestamp()) {
+                $stats['unchanged']++;
+                continue;
+            }
+
+            $stats['updated']++;
+            if ($dryRun) {
+                continue;
+            }
+
+            $segnalazione->timestamps = false;
+            $segnalazione->updated_at = $restored;
+            $segnalazione->saveQuietly();
+            $segnalazione->timestamps = true;
+        }
+
+        return $stats;
+    }
+
+    protected static function saveWithoutTouchingTimestamps(Segnalazione $segnalazione): void
+    {
+        Segnalazione::withoutAuditing(function () use ($segnalazione) {
+            $segnalazione->timestamps = false;
+            $segnalazione->saveQuietly();
+            $segnalazione->timestamps = true;
+        });
+    }
+
     /**
      * @return list<string>
      */
 
     protected function stampSegnalazioneFromLastAnnotazione(Segnalazione $segnalazione, mixed $created = null): void
     {
-        $createdAt = $created instanceof Carbon ? $created : $this->parseDate($created);
+        $createdAt = $created instanceof Carbon ? $created : self::parseDate($created);
         $createdAt = $createdAt ?? $segnalazione->created_at;
-        $updatedAt = $this->lastActivityAt($segnalazione) ?? $createdAt;
+        $updatedAt = self::lastActivityAt($segnalazione) ?? $createdAt;
 
         $segnalazione->timestamps = false;
         if ($createdAt) {
         $segnalazione->saveQuietly();
     }
 
-    protected function lastAnnotazioneAt(Segnalazione $segnalazione): ?Carbon
+    protected static function lastAnnotazioneAt(Segnalazione $segnalazione): ?Carbon
     {
         $latest = null;
         $rows = Annotazione::query()
         foreach ($rows as $annotazione) {
             foreach (['updated_at', 'created_at', 'tempo_data'] as $column) {
                 $raw = $annotazione->getAttributes()[$column] ?? null;
-                $parsed = $this->parseDate($raw);
+                $parsed = self::parseDate($raw);
                 if ($parsed && ($latest === null || $parsed->gt($latest))) {
                     $latest = $parsed;
                 }
         return $latest;
     }
 
-    protected function lastActivityAt(Segnalazione $segnalazione): ?Carbon
+    protected static function lastActivityAt(Segnalazione $segnalazione): ?Carbon
     {
-        $latest = $this->lastAnnotazioneAt($segnalazione);
+        $latest = self::lastAnnotazioneAt($segnalazione);
 
         $auditAt = Audit::query()
             ->where('auditable_type', $segnalazione->getMorphClass())
             ->where('tags', 'redmine')
             ->max('created_at');
 
-        $parsed = $this->parseDate($auditAt);
+        $parsed = self::parseDate($auditAt);
         if ($parsed && ($latest === null || $parsed->gt($latest))) {
             return $parsed;
         }
 
     protected function stampDates(Annotazione $annotazione, mixed $created, mixed $updated): void
     {
-        $createdAt = $created instanceof Carbon ? $created : $this->parseDate($created);
-        $updatedAt = $updated instanceof Carbon ? $updated : $this->parseDate($updated);
+        $createdAt = $created instanceof Carbon ? $created : self::parseDate($created);
+        $updatedAt = $updated instanceof Carbon ? $updated : self::parseDate($updated);
         if (! $createdAt) {
             return;
         }
         $annotazione->timestamps = true;
     }
 
-    protected function parseDate(mixed $value): ?Carbon
+    protected static function parseDate(mixed $value): ?Carbon
     {
         if ($value instanceof Carbon) {
             return $value;
         }
+        if ($value instanceof \DateTimeInterface) {
+            return Carbon::parse($value);
+        }
         if (! is_string($value) || trim($value) === '') {
             return null;
         }