96084499f5
Il gruppo ha un sorvegliante (proclamatore con utenza: email e password temporanea, senza conferma dell'email) e dei membri; l'amministratore mette in blocco dei territori nel pacchetto del gruppo. Il pacchetto non e' un'assegnazione e non tocca le statistiche; quando il sorvegliante da' un territorio a un membro nasce un'assegnazione normale con gruppo_servizio_id. Al rientro il territorio torna in reparto. Sciogliere il gruppo libera pacchetto e membri e disattiva l'utenza. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
377 lines
13 KiB
PHP
377 lines
13 KiB
PHP
<?php
|
|
|
|
namespace App\Models;
|
|
|
|
use Carbon\Carbon;
|
|
use Illuminate\Database\Eloquent\Model;
|
|
use Illuminate\Support\Str;
|
|
|
|
class Assegnazione extends Model
|
|
{
|
|
protected $table = 'assegnazioni';
|
|
|
|
protected $fillable = [
|
|
'territorio_id',
|
|
'proclamatore_id',
|
|
'anno_teocratico_id',
|
|
'assigned_at',
|
|
'returned_at',
|
|
'counted_in_campaign',
|
|
'campaign_id',
|
|
'pdf_access_code',
|
|
'link_sent',
|
|
'link_da_inviare',
|
|
'link_canale',
|
|
'note',
|
|
'created_by',
|
|
'returned_by',
|
|
'gruppo_servizio_id',
|
|
];
|
|
|
|
/** Il gruppo di servizio da cui è nata (data dal sorvegliante a un membro). */
|
|
public function gruppo()
|
|
{
|
|
return $this->belongsTo(GruppoServizio::class, 'gruppo_servizio_id');
|
|
}
|
|
|
|
protected function casts(): array
|
|
{
|
|
return [
|
|
'assigned_at' => 'date',
|
|
'returned_at' => 'date',
|
|
'counted_in_campaign' => 'boolean',
|
|
'link_sent' => 'boolean',
|
|
'link_da_inviare' => 'boolean',
|
|
'gruppo_servizio_id' => 'integer',
|
|
];
|
|
}
|
|
|
|
protected static function booted(): void
|
|
{
|
|
// Assegnare un territorio ne azzera il flag "prioritario": una volta in
|
|
// carico a un proclamatore (assegnazione aperta) non ha più senso
|
|
// segnalarlo come prioritario. La priorità automatica per soglia di
|
|
// giacenza riguarda solo i territori in reparto, quindi resta il solo
|
|
// flag manuale da spegnere. Vale per ogni via di creazione (pagina
|
|
// Assegna, CRUD del Registro, import XML di assegnazioni aperte).
|
|
static::created(function (self $assegnazione): void {
|
|
if ($assegnazione->returned_at !== null) {
|
|
return;
|
|
}
|
|
|
|
$territorio = $assegnazione->territorio;
|
|
if ($territorio && $territorio->prioritario) {
|
|
$territorio->update(['prioritario' => false]);
|
|
}
|
|
});
|
|
|
|
// Al rientro un territorio del pacchetto di un gruppo torna in reparto
|
|
// ed esce dal pacchetto. Qui e non nella pagina Rientra: vale per ogni
|
|
// via (rientro del sorvegliante, dell'amministratore, Registro).
|
|
static::updated(function (self $assegnazione): void {
|
|
if (! $assegnazione->wasChanged('returned_at') || $assegnazione->returned_at === null) {
|
|
return;
|
|
}
|
|
|
|
Territorio::withTrashed()
|
|
->whereKey($assegnazione->territorio_id)
|
|
->whereNotNull('gruppo_servizio_id')
|
|
->update(['gruppo_servizio_id' => null]);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* L'assegnazione dello stesso territorio il cui periodo si sovrappone a
|
|
* quello indicato, oppure null. Un'assegnazione aperta dura fino a oggi e
|
|
* oltre; rientro e nuova uscita nello stesso giorno non si sovrappongono.
|
|
*
|
|
* Copre in un colpo solo la doppia assegnazione aperta, l'uscita
|
|
* retrodatata a prima dell'ultimo rientro e le correzioni a mano nel
|
|
* Registro che accavallano due periodi. Il confronto è fatto in PHP sulle
|
|
* poche assegnazioni del territorio: in SQL dipenderebbe da come il
|
|
* driver memorizza le DATE (MariaDB "Y-m-d", SQLite "Y-m-d H:i:s").
|
|
*/
|
|
public static function sovrappostaA(
|
|
int $territorioId,
|
|
Carbon $uscita,
|
|
?Carbon $rientro = null,
|
|
?int $esclusaId = null
|
|
): ?self {
|
|
$uscita = $uscita->copy()->startOfDay();
|
|
$rientro = $rientro?->copy()->startOfDay();
|
|
|
|
return static::with('proclamatore')
|
|
->where('territorio_id', $territorioId)
|
|
->when($esclusaId, fn ($q) => $q->whereKeyNot($esclusaId))
|
|
->orderBy('assigned_at')
|
|
->get()
|
|
->first(fn (self $altra) => ($rientro === null || $altra->assigned_at->lt($rientro))
|
|
&& ($altra->returned_at === null || $uscita->lt($altra->returned_at)));
|
|
}
|
|
|
|
/** Descrizione del periodo per i messaggi d'errore: "a Rossi Mario dal 01/09/2025 al 15/10/2025". */
|
|
public function descrizionePeriodo(): string
|
|
{
|
|
$chi = $this->proclamatore?->nome_completo ?? 'un proclamatore';
|
|
$al = $this->returned_at ? ' al ' . $this->returned_at->format('d/m/Y') : ', non ancora rientrato';
|
|
|
|
return "a {$chi} dal {$this->assigned_at->format('d/m/Y')}{$al}";
|
|
}
|
|
|
|
// ─── Relationships ─────────────────────────────────────────
|
|
|
|
public function territorio()
|
|
{
|
|
return $this->belongsTo(Territorio::class, 'territorio_id')->withTrashed();
|
|
}
|
|
|
|
public function proclamatore()
|
|
{
|
|
return $this->belongsTo(Proclamatore::class, 'proclamatore_id')->withTrashed();
|
|
}
|
|
|
|
public function annoTeocratico()
|
|
{
|
|
return $this->belongsTo(AnnoTeocratico::class, 'anno_teocratico_id');
|
|
}
|
|
|
|
public function campagna()
|
|
{
|
|
return $this->belongsTo(Campagna::class, 'campaign_id');
|
|
}
|
|
|
|
public function creatoDa()
|
|
{
|
|
return $this->belongsTo(User::class, 'created_by');
|
|
}
|
|
|
|
public function rientratoDa()
|
|
{
|
|
return $this->belongsTo(User::class, 'returned_by');
|
|
}
|
|
|
|
// ─── Computed ───────────────────────────────────────────────
|
|
|
|
/**
|
|
* Number of days between assignment and return (or today if still open).
|
|
*/
|
|
public function getGiorniAttribute(): int
|
|
{
|
|
$end = $this->returned_at ?? now();
|
|
// Carbon 3 restituisce un float: i giorni interi trascorsi.
|
|
return (int) Carbon::parse($this->assigned_at)->diffInDays($end);
|
|
}
|
|
|
|
public function getIsApertaAttribute(): bool
|
|
{
|
|
return is_null($this->returned_at);
|
|
}
|
|
|
|
/**
|
|
* Scadenza dell'assegnazione: data entro cui il territorio andrebbe
|
|
* riconsegnato, cioè assigned_at + la soglia "giorni_per_smarrito" (la
|
|
* stessa oltre cui Territorio::stato diventa "da_rientrare"). Null per le
|
|
* assegnazioni già rientrate.
|
|
*/
|
|
public function getDataConsegnaPresuntaAttribute(): ?Carbon
|
|
{
|
|
if ($this->returned_at !== null) {
|
|
return null;
|
|
}
|
|
|
|
$soglia = (int) Setting::getValue('giorni_per_smarrito', 120);
|
|
|
|
return Carbon::parse($this->assigned_at)->addDays($soglia);
|
|
}
|
|
|
|
/**
|
|
* Giorni che mancano alla scadenza: positivo se ancora entro i termini,
|
|
* negativo (giorni di ritardo) se già scaduta. Null se rientrata.
|
|
*/
|
|
public function getGiorniAllaScadenzaAttribute(): ?int
|
|
{
|
|
$scadenza = $this->data_consegna_presunta?->copy()->startOfDay();
|
|
if (! $scadenza) {
|
|
return null;
|
|
}
|
|
|
|
$oggi = Carbon::today();
|
|
$giorni = (int) $oggi->diffInDays($scadenza);
|
|
|
|
return $oggi->lessThanOrEqualTo($scadenza) ? $giorni : -$giorni;
|
|
}
|
|
|
|
public function ensurePdfAccessCode(): string
|
|
{
|
|
if ($this->pdf_access_code) {
|
|
return $this->pdf_access_code;
|
|
}
|
|
|
|
do {
|
|
$code = strtoupper(Str::random(12));
|
|
} while (static::query()->where('pdf_access_code', $code)->exists());
|
|
|
|
$this->forceFill(['pdf_access_code' => $code])->saveQuietly();
|
|
|
|
return $code;
|
|
}
|
|
|
|
public function temporaryPdfViewerUrl(): ?string
|
|
{
|
|
if (! $this->is_aperta || ! $this->territorio?->pdf_path) {
|
|
return null;
|
|
}
|
|
|
|
return route('assignments.pdf.viewer', [
|
|
'assignment' => $this->id,
|
|
'code' => $this->ensurePdfAccessCode(),
|
|
]);
|
|
}
|
|
|
|
public function shortPdfUrl(): ?string
|
|
{
|
|
if (! $this->is_aperta || ! $this->territorio?->pdf_path) {
|
|
return null;
|
|
}
|
|
|
|
return route('assignments.pdf.short', ['code' => $this->ensurePdfAccessCode()]);
|
|
}
|
|
|
|
public function markLinkSent(?string $canale = null): void
|
|
{
|
|
$this->registraInvioLink(true, $canale);
|
|
}
|
|
|
|
/**
|
|
* Canali con cui si manda il link al proclamatore. Dal 19 ottobre 2026 se
|
|
* ne usano due: copia link e Condividi (il menu di condivisione del
|
|
* telefono); il destinatario lo sceglie chi usa l'app. "whatsapp" ed
|
|
* "email" restano solo perché le assegnazioni già inviate così lo
|
|
* mostrino e l'XML lo accetti.
|
|
*/
|
|
public const CANALI_LINK = ['copia' => 'Copia link', 'condividi' => 'Condividi', 'whatsapp' => 'WhatsApp', 'email' => 'Email'];
|
|
|
|
/** I canali che si possono scegliere oggi nella finestra di invio. */
|
|
public const CANALI_ATTIVI = ['copia', 'condividi'];
|
|
|
|
/**
|
|
* Esito dell'invio del link: inviato (con il canale usato) oppure no. Un
|
|
* link non inviato resta "da inviare" e lo si segnala sull'assegnazione,
|
|
* a meno che non ci sia proprio un link da mandare (territorio senza PDF).
|
|
*/
|
|
public function registraInvioLink(bool $inviato, ?string $canale = null): void
|
|
{
|
|
$this->forceFill([
|
|
'link_sent' => $inviato,
|
|
'link_da_inviare' => ! $inviato && $this->shortPdfUrl() !== null,
|
|
'link_canale' => $inviato ? $canale : $this->link_canale,
|
|
])->saveQuietly();
|
|
}
|
|
|
|
/** Il link va ancora mandato: l'avviso da mostrare sull'assegnazione. */
|
|
public function getLinkInSospesoAttribute(): bool
|
|
{
|
|
return $this->link_da_inviare && ! $this->link_sent && $this->is_aperta;
|
|
}
|
|
|
|
/**
|
|
* Il messaggio con il link, per "Condividi": il menu di condivisione del
|
|
* telefono, da cui chi usa l'app sceglie app e contatto. L'app non vede
|
|
* quei contatti.
|
|
*/
|
|
public function messaggioLink(?string $link = null): ?string
|
|
{
|
|
$link ??= $this->shortPdfUrl();
|
|
if ($link === null) {
|
|
return null;
|
|
}
|
|
|
|
return "Ciao {$this->proclamatore?->nome}, ti è stato assegnato il territorio N° {$this->territorio?->numero}. Ecco la piantina: {$link}";
|
|
}
|
|
|
|
// ─── Scopes ─────────────────────────────────────────────────
|
|
|
|
public function scopeAperte($query)
|
|
{
|
|
return $query->whereNull('returned_at');
|
|
}
|
|
|
|
public function scopeChiuse($query)
|
|
{
|
|
return $query->whereNotNull('returned_at');
|
|
}
|
|
|
|
public function scopePerAnnoTeocratico($query, $annoId)
|
|
{
|
|
return $query->where('anno_teocratico_id', $annoId);
|
|
}
|
|
|
|
// ─── Business Logic ─────────────────────────────────────────
|
|
|
|
/**
|
|
* Registra nell'audit log la scelta dell'operatore sul conteggio in
|
|
* campagna: evento dedicato "campagna_percorso", leggibile senza dover
|
|
* interpretare le proprietà dell'evento "returned".
|
|
*/
|
|
public function logCampagnaPercorso(?Campagna $campagna, bool $percorso, string $origine): void
|
|
{
|
|
$this->loadMissing('territorio');
|
|
|
|
$giorni = $this->giorniPercorrenza();
|
|
$soglia = static::sogliaPercorrenzaElevata();
|
|
|
|
activity()->causedBy(auth()->user())
|
|
->performedOn($this)
|
|
->withProperties([
|
|
'territorio' => $this->territorio?->numero,
|
|
'proclamatore_id' => $this->proclamatore_id, // vedi Assegna: niente nomi in chiaro
|
|
'campagna' => $campagna?->descrizione,
|
|
'percorso_in_campagna' => $percorso ? 'Sì' : 'No',
|
|
'giorni_percorrenza' => $giorni,
|
|
'avviso_tempo_elevato' => $giorni > $soglia ? "Sì (soglia {$soglia} giorni)" : 'No',
|
|
'origine' => $origine,
|
|
])
|
|
->log('campagna_percorso');
|
|
}
|
|
|
|
/**
|
|
* Giorni tra assegnazione e rientro (o la data indicata, o oggi).
|
|
*/
|
|
public function giorniPercorrenza(?Carbon $returnDate = null): int
|
|
{
|
|
$end = $returnDate ?? $this->returned_at ?? now();
|
|
|
|
return (int) Carbon::parse($this->assigned_at)->startOfDay()->diffInDays(Carbon::parse($end)->startOfDay());
|
|
}
|
|
|
|
/**
|
|
* Oltre questa soglia il tempo di percorrenza è considerato molto alto:
|
|
* è la stessa soglia "giorni_per_smarrito" dello stato "da_rientrare".
|
|
*/
|
|
public static function sogliaPercorrenzaElevata(): int
|
|
{
|
|
return (int) Setting::getValue('giorni_per_smarrito', 120);
|
|
}
|
|
|
|
/**
|
|
* Check if a campaign prompt should be shown when returning this assignment.
|
|
* Returns the matching campaign or null.
|
|
*/
|
|
public function campagnaApplicabile(?\Carbon\Carbon $returnDate = null): ?Campagna
|
|
{
|
|
$returnDate = ($returnDate ?? now())->toDateString();
|
|
$assignedAt = $this->assigned_at->toDateString();
|
|
|
|
// Il territorio può essere conteggiato per una campagna se è rimasto
|
|
// in mano al proclamatore almeno in parte del periodo: assegnato
|
|
// durante la campagna, rientrato durante la campagna, oppure fuori per
|
|
// tutta la sua durata (assegnato prima e rientrato dopo). Se sia stato
|
|
// davvero percorso lo decide l'operatore con la spunta.
|
|
// Se più campagne corrispondono si propone la più recente.
|
|
return Campagna::where('start_date', '<=', $returnDate)
|
|
->where('end_date', '>=', $assignedAt)
|
|
->orderByDesc('start_date')
|
|
->first();
|
|
}
|
|
}
|