task

.env.example

@@ -114,4 +114,10 @@ SKEBBY_MESSAGE_TYPE=GP
 # Token manuale con scope entity.clients:r e entity.clients:a
 # FATTUREINCLOUD_COMPANY_ID=
 # FATTUREINCLOUD_ACCESS_TOKEN=
+
+# Task da Telegram (in alternativa: Configurazione > Task)
+# TELEGRAM_BOT_TOKEN=
+# TELEGRAM_WEBHOOK_SECRET=
+# OPENAI_API_KEY=
+# OPENAI_TRANSCRIBE_MODEL=whisper-1
 # SKEBBY_BASE_URL=https://api.skebby.it/API/v1.0/REST

app/Http/Controllers/ConfigController.php

@@ -9,10 +9,12 @@ use App\Models\Azienda;
 use App\Models\Config;
 use App\Models\ConfiguraSegnalazione;
 use App\Services\FattureInCloudClient;
+use App\Services\TelegramBotService;
 use RuntimeException;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Log;
 use Illuminate\Support\Facades\Storage;
+use Illuminate\Support\Str;
 use Intervention\Image\ImageManager;
 use Intervention\Image\Drivers\Imagick\Driver;
 
@@ -28,7 +30,7 @@ class ConfigController extends Controller implements HasMiddleware
   {
     return [
       new Middleware('permission:view-config', only: ['index', 'admin_index']),
-      new Middleware('permission:edit-config', only: ['store', 'admin_save', 'admin_sync_aliquote']),
+      new Middleware('permission:edit-config', only: ['store', 'admin_save', 'admin_sync_aliquote', 'admin_telegram_webhook']),
     ];
   }
 
@@ -131,6 +133,51 @@ class ConfigController extends Controller implements HasMiddleware
       ->with('success', 'Aliquote IVA aggiornate da Fatture in Cloud ('.$n.'). Segna quella da usare di default e salva.');
   }
 
+  public function admin_telegram_webhook(Request $request, TelegramBotService $telegram)
+  {
+    Config::syncDefinitions();
+
+    $postedToken = trim((string) $request->input('value.'.Config::TELEGRAM_BOT_TOKEN, ''));
+    if ($postedToken !== '') {
+      $tokenRow = Config::find(Config::TELEGRAM_BOT_TOKEN);
+      if ($tokenRow) {
+        $tokenRow->value = $postedToken;
+        $tokenRow->save();
+      }
+    }
+
+    if ($telegram->token() === null) {
+      return redirect()->route('admin.config.index')
+        ->with('config_group', 'Task')
+        ->withErrors(['telegram' => 'Salva prima il token del bot Telegram.']);
+    }
+
+    $secret = Config::telegramWebhookSecret();
+    if ($secret === null) {
+      $secret = Str::random(40);
+      $row = Config::find(Config::TELEGRAM_WEBHOOK_SECRET);
+      if (! $row) {
+        return redirect()->route('admin.config.index')
+          ->with('config_group', 'Task')
+          ->withErrors(['telegram' => 'Voce di configurazione del secret non trovata.']);
+      }
+      $row->value = $secret;
+      $row->save();
+    }
+
+    try {
+      $telegram->setWebhook(route('telegram.task.webhook'), $secret);
+    } catch (RuntimeException $e) {
+      return redirect()->route('admin.config.index')
+        ->with('config_group', 'Task')
+        ->withErrors(['telegram' => $e->getMessage()]);
+    }
+
+    return redirect()->route('admin.config.index')
+      ->with('config_group', 'Task')
+      ->with('success', 'Bot Telegram collegato. I messaggi arrivano su '.route('telegram.task.webhook'));
+  }
+
   protected function normalizeValue(?string $type, mixed $value): ?string
   {
     return match ($type) {
@@ -141,6 +188,7 @@ class ConfigController extends Controller implements HasMiddleware
       'stato' => $value === null || $value === '' ? null : (string) $value,
       'stati' => json_encode($this->normalizeStati($value), JSON_UNESCAPED_UNICODE),
       'tipo' => $value === null || $value === '' ? null : (string) $value,
+      'lines' => json_encode($this->normalizeLines($value), JSON_UNESCAPED_UNICODE),
       default => $value === null ? null : (string) $value,
     };
   }
@@ -168,6 +216,20 @@ class ConfigController extends Controller implements HasMiddleware
     return array_values(array_unique($stati));
   }
 
+  protected function normalizeLines(mixed $value): array
+  {
+    $lines = preg_split('/\r\n|\r|\n/', (string) $value) ?: [];
+    $out = [];
+    foreach ($lines as $line) {
+      $line = trim($line);
+      if ($line !== '') {
+        $out[] = $line;
+      }
+    }
+
+    return array_values(array_unique($out));
+  }
+
   public function createToken(Request $request){
     $token = $request->user()->createToken("tokenEventi");
 

app/Http/Controllers/HomePageController.php

@@ -10,6 +10,7 @@ use App\Models\Config;
 use App\Models\ConfiguraSegnalazione;
 use App\Models\Prodotto;
 use App\Models\Segnalazione;
+use App\Models\Task;
 use App\Models\User;
 use Carbon\Carbon;
 use Illuminate\Database\Eloquent\Builder;
@@ -119,6 +120,26 @@ class HomePageController extends Controller
       ->values()
       ->all();
 
+    $mostraTasks = Auth::user()?->can('view-task') ?? false;
+    $tasksVista = 'inserimento';
+    $tasksPresentazione = ['prioritari' => collect(), 'sezioni' => []];
+    $tipoLabels = [];
+    if ($mostraTasks) {
+      $tasksVista = (string) request()->query('vista', session('tasks_vista', 'inserimento'));
+      if (! in_array($tasksVista, ['inserimento', 'settore'], true)) {
+        $tasksVista = 'inserimento';
+      }
+      session(['tasks_vista' => $tasksVista]);
+      $tipi = Config::tipiSegnalazione();
+      $tipoLabels = Config::tipiSegnalazioneLabels();
+      $tasksPresentazione = Task::presenta(
+        Task::query()->aperti()->with('segnalazione')->orderByDesc('prioritario')->orderBy('id')->get(),
+        $tasksVista,
+        array_column($tipi, 'value'),
+        $tipoLabels
+      );
+    }
+
     return [
       'totaleSegnalazioni' => $totaleSegnalazioni,
       'segnalazioniAperte' => $segnalazioniAperte,
@@ -131,6 +152,10 @@ class HomePageController extends Controller
       'timerUsers' => $timerUsers,
       'slotPrenotazioni' => $slotPrenotazioni,
       'tempoLavorato' => $this->getTempoLavoratoStats(),
+      'mostraTasks' => $mostraTasks,
+      'tasksVista' => $tasksVista,
+      'tasksPresentazione' => $tasksPresentazione,
+      'tipoLabels' => $tipoLabels,
     ];
   }
 

app/Http/Controllers/TaskController.php

@@ -0,0 +1,272 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Annotazione;
+use App\Models\Config;
+use App\Models\Segnalazione;
+use App\Models\Task;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Controllers\HasMiddleware;
+use Illuminate\Routing\Controllers\Middleware;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Validation\Rule;
+use Illuminate\Validation\ValidationException;
+
+class TaskController extends Controller implements HasMiddleware
+{
+    public static $permission_group = 'Task';
+
+    public static $permissions = [
+        'view-task' => 'Vedi',
+        'create-task' => 'Crea',
+        'edit-task' => 'Modifica',
+        'delete-task' => 'Elimina',
+    ];
+
+    public static function middleware(): array
+    {
+        return [
+            new Middleware('permission:view-task', only: ['admin_index', 'admin_segnalazioni']),
+            new Middleware('permission:create-task', only: ['admin_store']),
+            new Middleware('permission:edit-task', only: ['admin_edit', 'admin_update', 'admin_toggle']),
+            new Middleware('permission:delete-task', only: ['admin_destroy']),
+        ];
+    }
+
+    public function admin_index(Request $request)
+    {
+        return view('task.index', $this->pageData($request));
+    }
+
+    public function admin_edit(Request $request, $id)
+    {
+        $task = Task::query()->findOrFail($id);
+
+        return view('task.index', $this->pageData($request, $task));
+    }
+
+    public function admin_store(Request $request)
+    {
+        $data = $this->validated($request);
+        $task = new Task();
+        $task->user_id = Auth::id();
+        $task->origine = 'web';
+        $this->fillAndSave($task, $data, $request);
+
+        return redirect()->route('admin.task.index')->with('success', 'Task aggiunto.');
+    }
+
+    public function admin_update(Request $request, $id)
+    {
+        $task = Task::query()->findOrFail($id);
+        $data = $this->validated($request, $task);
+        $this->fillAndSave($task, $data, $request);
+
+        return redirect()->route('admin.task.index')->with('success', 'Task aggiornato.');
+    }
+
+    public function admin_toggle($id)
+    {
+        $task = Task::query()->findOrFail($id);
+        $task->completato_at = $task->isCompletato() ? null : now();
+        $task->save();
+
+        return redirect()->back()->with('success', $task->isCompletato() ? 'Task completato.' : 'Task riaperto.');
+    }
+
+    public function admin_destroy($id)
+    {
+        Task::query()->findOrFail($id)->delete();
+
+        return redirect()->route('admin.task.index')->with('success', 'Task eliminato.');
+    }
+
+    public function admin_segnalazioni(Request $request)
+    {
+        $q = trim((string) $request->query('q', ''));
+        $rows = Segnalazione::query()
+            ->when($q !== '', function ($query) use ($q) {
+                $query->where(function ($inner) use ($q) {
+                    $inner->where('titolo', 'like', '%'.$q.'%');
+                    if (ctype_digit($q)) {
+                        $inner->orWhere('id', (int) $q);
+                    }
+                });
+            })
+            ->orderByDesc('id')
+            ->limit(15)
+            ->get(['id', 'titolo', 'stato', 'tipo']);
+
+        return response()->json($rows->map(fn (Segnalazione $segnalazione) => [
+            'id' => $segnalazione->id,
+            'label' => $segnalazione->getLabel(),
+            'stato' => $segnalazione->stato,
+            'tipo' => $segnalazione->tipo,
+        ])->values());
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function pageData(Request $request, ?Task $task = null): array
+    {
+        $task ??= new Task();
+        $stato = $request->query('stato', 'aperte');
+        if (! in_array($stato, ['aperte', 'completate', 'tutte'], true)) {
+            $stato = 'aperte';
+        }
+
+        $query = Task::query()->with('segnalazione')->inElenco();
+        if ($stato === 'aperte') {
+            $query->whereNull('completato_at');
+        } elseif ($stato === 'completate') {
+            $query->whereNotNull('completato_at');
+        }
+
+        $tasks = $query->get();
+        $tipi = Config::tipiSegnalazione();
+        $settori = array_column($tipi, 'value');
+        $tipoLabels = Config::tipiSegnalazioneLabels();
+        $vista = $this->vista($request);
+        $selezionataId = old('segnalazione_id', $task->segnalazione_id);
+        $selezionata = $selezionataId ? Segnalazione::query()->find($selezionataId) : null;
+
+        return [
+            'task' => $task,
+            'stato' => $stato,
+            'vista' => $vista,
+            'tipi' => $tipi,
+            'settori' => $settori,
+            'tipoLabels' => $tipoLabels,
+            'presentazione' => Task::presenta($tasks, $vista, $settori, $tipoLabels),
+            'totale' => $tasks->count(),
+            'segnalazioneSelezionata' => $selezionata,
+            'puoCreareSegnalazione' => Auth::user()?->can('create-segnalazione') ?? false,
+            'canCreate' => Auth::user()?->can('create-task') ?? false,
+            'canEdit' => Auth::user()?->can('edit-task') ?? false,
+            'canDelete' => Auth::user()?->can('delete-task') ?? false,
+        ];
+    }
+
+    private function vista(Request $request): string
+    {
+        $vista = (string) $request->query('vista', session('tasks_vista', 'inserimento'));
+        if (! in_array($vista, ['inserimento', 'settore'], true)) {
+            $vista = 'inserimento';
+        }
+        session(['tasks_vista' => $vista]);
+
+        return $vista;
+    }
+
+    /**
+     * @return array{testo: string, settore: ?string, tempo_minuti: ?int, prioritario: bool, mode: string}
+     */
+    private function validated(Request $request, ?Task $task = null): array
+    {
+        $ammessi = array_column(Config::tipiSegnalazione(), 'value');
+        if ($task?->settore) {
+            $ammessi[] = $task->settore;
+        }
+
+        $validated = $request->validate([
+            'testo' => 'required|string|max:5000',
+            'settore' => ['nullable', 'string', Rule::in($ammessi)],
+            'tempo' => 'nullable|string|max:20',
+            'prioritario' => 'sometimes|boolean',
+            'segnalazione_mode' => 'required|in:nessuna,esistente,nuova',
+            'segnalazione_id' => 'nullable|integer|exists:segnalazione,id',
+            'nuova_segnalazione_titolo' => 'nullable|string|max:255',
+        ]);
+
+        if ($validated['segnalazione_mode'] === 'esistente' && empty($validated['segnalazione_id'])) {
+            throw ValidationException::withMessages([
+                'segnalazione_id' => 'Seleziona la segnalazione da collegare.',
+            ]);
+        }
+
+        if ($validated['segnalazione_mode'] === 'nuova' && ! Auth::user()?->can('create-segnalazione')) {
+            throw ValidationException::withMessages([
+                'segnalazione_mode' => 'Non hai il permesso per creare una segnalazione.',
+            ]);
+        }
+
+        $tempo = null;
+        $tempoRaw = trim((string) ($validated['tempo'] ?? ''));
+        if ($tempoRaw !== '') {
+            $tempo = Config::parseTempoToMinuti($tempoRaw);
+            if ($tempo === null) {
+                throw ValidationException::withMessages([
+                    'tempo' => 'Tempo non valido. Usa 45m, 1h30m oppure 1,5.',
+                ]);
+            }
+        }
+
+        return [
+            'testo' => trim($validated['testo']),
+            'settore' => ($validated['settore'] ?? '') !== '' ? $validated['settore'] : null,
+            'tempo_minuti' => $tempo,
+            'prioritario' => $request->boolean('prioritario'),
+            'mode' => $validated['segnalazione_mode'],
+        ];
+    }
+
+    /**
+     * @param  array{testo: string, settore: ?string, tempo_minuti: ?int, prioritario: bool, mode: string}  $data
+     */
+    private function fillAndSave(Task $task, array $data, Request $request): void
+    {
+        DB::transaction(function () use ($task, $data, $request) {
+            $task->testo = $data['testo'];
+            $task->settore = $data['settore'];
+            $task->tempo_stimato_minuti = $data['tempo_minuti'];
+            $task->prioritario = $data['prioritario'];
+
+            if ($data['mode'] === 'nessuna') {
+                $task->segnalazione_id = null;
+            } elseif ($data['mode'] === 'esistente') {
+                $segnalazione = Segnalazione::query()->findOrFail((int) $request->input('segnalazione_id'));
+                if ($data['settore']) {
+                    $segnalazione->tipo = $data['settore'];
+                    $segnalazione->save();
+                } else {
+                    $task->settore = $segnalazione->tipo ?: null;
+                }
+                $task->segnalazione_id = $segnalazione->id;
+            } else {
+                $titolo = trim((string) $request->input('nuova_segnalazione_titolo', ''));
+                if ($titolo === '') {
+                    $titolo = preg_replace('/\s+/u', ' ', $data['testo']) ?? $data['testo'];
+                }
+                $task->segnalazione_id = $this->creaSegnalazione($titolo, $data['testo'], $data['settore'])->id;
+            }
+
+            $task->save();
+        });
+    }
+
+    private function creaSegnalazione(string $titolo, string $testo, ?string $tipo): Segnalazione
+    {
+        $segnalazione = new Segnalazione();
+        $segnalazione->titolo = mb_substr($titolo, 0, 255);
+        $segnalazione->stato = Config::getStatoSegnalazioneDefault();
+        $segnalazione->priorita = Config::getPrioritaSegnalazioneDefault();
+        $segnalazione->tipo = $tipo;
+        $segnalazione->origine = 'task';
+        $segnalazione->user_id = Auth::id();
+        $segnalazione->notificaApertaDa = false;
+        $segnalazione->notificaAdmin = false;
+        $segnalazione->save();
+
+        $annotazione = new Annotazione();
+        $annotazione->segnalazione_id = $segnalazione->id;
+        $annotazione->user_id = Auth::id();
+        $annotazione->text = nl2br(e($testo));
+        $annotazione->riservata = true;
+        $annotazione->save();
+
+        return $segnalazione;
+    }
+}

app/Http/Controllers/TelegramTaskController.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Config;
+use App\Services\TelegramTaskIntake;
+use Illuminate\Http\Request;
+
+class TelegramTaskController extends Controller
+{
+    public function webhook(Request $request, TelegramTaskIntake $intake)
+    {
+        $expected = Config::telegramWebhookSecret();
+        $given = (string) $request->header('X-Telegram-Bot-Api-Secret-Token', '');
+        if ($expected === null || $given === '' || ! hash_equals($expected, $given)) {
+            abort(403);
+        }
+
+        $payload = $request->all();
+        if (! is_array($payload)) {
+            $payload = [];
+        }
+        $intake->handle($payload);
+
+        return response()->json(['ok' => true]);
+    }
+}

app/Models/Config.php

@@ -34,6 +34,12 @@ class Config extends \App\Models\AbstractModels\AbstractConfig
   const FIC_ACCESS_TOKEN = 'FIC_ACCESS_TOKEN';
   const FIC_ALIQUOTE = 'FIC_ALIQUOTE';
 
+  const TELEGRAM_BOT_TOKEN = 'TELEGRAM_BOT_TOKEN';
+  const TELEGRAM_WEBHOOK_SECRET = 'TELEGRAM_WEBHOOK_SECRET';
+  const TELEGRAM_ALLOWED_IDS = 'TELEGRAM_ALLOWED_IDS';
+  const OPENAI_API_KEY = 'OPENAI_API_KEY';
+  const OPENAI_TRANSCRIBE_MODEL = 'OPENAI_TRANSCRIBE_MODEL';
+
   public static function getConfig(){
     $config = [];
 
@@ -82,6 +88,14 @@ class Config extends \App\Models\AbstractModels\AbstractConfig
       ['key' => self::FIC_ALIQUOTE, 'value' => null, 'display_name' => 'Aliquote IVA', 'type' => 'aliquote'],
     ];
 
+    $config['Task'] = [
+      ['key' => self::TELEGRAM_BOT_TOKEN, 'value' => null, 'display_name' => 'Token bot Telegram', 'type' => 'password'],
+      ['key' => self::TELEGRAM_WEBHOOK_SECRET, 'value' => null, 'display_name' => 'Secret webhook Telegram', 'type' => 'password'],
+      ['key' => self::TELEGRAM_ALLOWED_IDS, 'value' => null, 'display_name' => 'ID Telegram autorizzati', 'type' => 'text'],
+      ['key' => self::OPENAI_API_KEY, 'value' => null, 'display_name' => 'Chiave OpenAI per i vocali', 'type' => 'password'],
+      ['key' => self::OPENAI_TRANSCRIBE_MODEL, 'value' => 'whisper-1', 'display_name' => 'Modello di trascrizione', 'type' => 'text'],
+    ];
+
     return $config;
   }
 
@@ -91,6 +105,7 @@ class Config extends \App\Models\AbstractModels\AbstractConfig
   public static function syncDefinitions(): void
   {
     self::where('key', 'colore_ruolo')->delete();
+    self::where('key', 'TASK_SETTORI')->delete();
 
     foreach (self::getConfig() as $group => $items) {
       $order = 1;
@@ -459,6 +474,96 @@ class Config extends \App\Models\AbstractModels\AbstractConfig
     return $date;
   }
 
+  /**
+   * Tipi segnalazione, usati anche come settore dei task.
+   *
+   * @return list<array{value: string, label: string}>
+   */
+  public static function tipiSegnalazione(): array
+  {
+    $tipi = [];
+    foreach (ConfiguraSegnalazione::query()->where('gruppo', 'Tipo')->orderBy('order')->orderBy('label')->get() as $tipo) {
+      $value = trim((string) $tipo->value);
+      if ($value === '') {
+        continue;
+      }
+      $label = trim((string) ($tipo->label ?: $value));
+      $tipi[] = [
+        'value' => $value,
+        'label' => $label !== '' ? $label : $value,
+      ];
+    }
+
+    return $tipi;
+  }
+
+  /**
+   * @return array<string, string>
+   */
+  public static function tipiSegnalazioneLabels(): array
+  {
+    $labels = [];
+    foreach (self::tipiSegnalazione() as $tipo) {
+      $labels[$tipo['value']] = $tipo['label'];
+    }
+
+    return $labels;
+  }
+
+  public static function tipoSegnalazioneLabel(?string $value): ?string
+  {
+    if ($value === null || trim($value) === '') {
+      return null;
+    }
+
+    return self::tipiSegnalazioneLabels()[$value] ?? $value;
+  }
+
+  public static function secretOrEnv(string $key, ?string $envValue): ?string
+  {
+    $value = trim((string) self::valueOf($key, ''));
+    if ($value === '') {
+      $value = trim((string) $envValue);
+    }
+
+    return $value !== '' ? $value : null;
+  }
+
+  public static function telegramBotToken(): ?string
+  {
+    return self::secretOrEnv(self::TELEGRAM_BOT_TOKEN, config('services.telegram.bot_token'));
+  }
+
+  public static function telegramWebhookSecret(): ?string
+  {
+    return self::secretOrEnv(self::TELEGRAM_WEBHOOK_SECRET, config('services.telegram.webhook_secret'));
+  }
+
+  /**
+   * @return list<int>
+   */
+  public static function telegramAllowedUserIds(): array
+  {
+    preg_match_all('/\d+/', (string) self::valueOf(self::TELEGRAM_ALLOWED_IDS, ''), $match);
+
+    return array_values(array_unique(array_map('intval', $match[0] ?? [])));
+  }
+
+  public static function openaiApiKey(): ?string
+  {
+    return self::secretOrEnv(self::OPENAI_API_KEY, config('services.openai.api_key'));
+  }
+
+  public static function openaiTranscribeModel(): string
+  {
+    $model = trim((string) self::valueOf(self::OPENAI_TRANSCRIBE_MODEL, ''));
+    if ($model === '') {
+      $model = trim((string) config('services.openai.transcribe_model', 'whisper-1'));
+    }
+
+    return $model !== '' ? $model : 'whisper-1';
+  }
+
   public static function formatCosto($value, $decimals = 2){
     return number_format($value, $decimals, ",",".",)." €";
   }

app/Models/Task.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Support\Collection;
+
+class Task extends Model
+{
+    protected $table = 'task';
+
+    protected $fillable = [
+        'testo',
+        'settore',
+        'tempo_stimato_minuti',
+        'prioritario',
+        'completato_at',
+        'segnalazione_id',
+        'user_id',
+        'origine',
+        'telegram_update_id',
+    ];
+
+    protected $casts = [
+        'prioritario' => 'boolean',
+        'tempo_stimato_minuti' => 'integer',
+        'completato_at' => 'datetime',
+        'telegram_update_id' => 'integer',
+    ];
+
+    public function segnalazione()
+    {
+        return $this->belongsTo(Segnalazione::class, 'segnalazione_id');
+    }
+
+    public function user()
+    {
+        return $this->belongsTo(User::class, 'user_id');
+    }
+
+    public function isCompletato(): bool
+    {
+        return $this->completato_at !== null;
+    }
+
+    public function scopeAperti(Builder $query): Builder
+    {
+        return $query->whereNull('completato_at');
+    }
+
+    public function scopeInElenco(Builder $query): Builder
+    {
+        return $query
+            ->orderByDesc('prioritario')
+            ->orderByRaw('CASE WHEN completato_at IS NULL THEN 0 ELSE 1 END')
+            ->orderBy('id');
+    }
+
+    /**
+     * I prioritari stanno sempre in cima. Il resto segue l'ordine di inserimento
+     * oppure viene raggruppato per settore.
+     *
+     * @param  Collection<int, self>  $tasks
+     * @param  list<string>  $settori
+     * @param  array<string, string>  $etichette
+     * @return array{prioritari: Collection<int, self>, sezioni: list<array{label: ?string, tasks: Collection<int, self>}>}
+     */
+    public static function presenta(Collection $tasks, string $vista, array $settori, array $etichette = []): array
+    {
+        $prioritari = $tasks->filter(fn (self $task) => $task->prioritario)->values();
+        $resto = $tasks->reject(fn (self $task) => $task->prioritario)->values();
+
+        if ($vista !== 'settore') {
+            return [
+                'prioritari' => $prioritari,
+                'sezioni' => [
+                    ['label' => null, 'tasks' => $resto],
+                ],
+            ];
+        }
+
+        $sezioni = [];
+        $noti = [];
+        foreach ($settori as $settore) {
+            $noti[$settore] = true;
+            $gruppo = $resto->filter(fn (self $task) => $task->settore === $settore)->values();
+            if ($gruppo->isNotEmpty()) {
+                $sezioni[] = ['label' => $etichette[$settore] ?? $settore, 'tasks' => $gruppo];
+            }
+        }
+
+        $altri = $resto->filter(function (self $task) use ($noti) {
+            return $task->settore === null || $task->settore === '' || ! isset($noti[$task->settore]);
+        })->values();
+        if ($altri->isNotEmpty()) {
+            $sezioni[] = ['label' => 'Senza tipo', 'tasks' => $altri];
+        }
+
+        return [
+            'prioritari' => $prioritari,
+            'sezioni' => $sezioni,
+        ];
+    }
+}

app/Services/AudioTranscriptionService.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Config;
+use Illuminate\Support\Facades\Http;
+use RuntimeException;
+
+class AudioTranscriptionService
+{
+    public function transcribe(string $contents, ?string $mime = null): string
+    {
+        $key = Config::openaiApiKey();
+        if ($key === null) {
+            throw new RuntimeException('Chiave OpenAI non configurata: non posso trascrivere l\'audio.');
+        }
+
+        $response = Http::withToken($key)
+            ->timeout(90)
+            ->attach('file', $contents, $this->filenameForMime($mime))
+            ->post('https://api.openai.com/v1/audio/transcriptions', [
+                'model' => Config::openaiTranscribeModel(),
+                'language' => 'it',
+            ]);
+
+        if (! $response->successful()) {
+            throw new RuntimeException('Trascrizione non riuscita.');
+        }
+
+        $text = trim((string) $response->json('text'));
+        if ($text === '') {
+            throw new RuntimeException('L\'audio non contiene un testo riconoscibile.');
+        }
+
+        return $text;
+    }
+
+    private function filenameForMime(?string $mime): string
+    {
+        return match ($mime) {
+            'audio/mpeg', 'audio/mp3' => 'audio.mp3',
+            'audio/mp4', 'audio/m4a', 'audio/x-m4a' => 'audio.m4a',
+            'audio/wav', 'audio/x-wav' => 'audio.wav',
+            'audio/webm' => 'audio.webm',
+            default => 'audio.ogg',
+        };
+    }
+}

app/Services/TelegramBotService.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Config;
+use Illuminate\Support\Facades\Http;
+use RuntimeException;
+
+class TelegramBotService
+{
+    public function token(): ?string
+    {
+        return Config::telegramBotToken();
+    }
+
+    /**
+     * @param  array<string, mixed>  $params
+     * @return array<string, mixed>
+     */
+    public function call(string $method, array $params = []): array
+    {
+        $token = $this->token();
+        if ($token === null) {
+            throw new RuntimeException('Token del bot Telegram non configurato.');
+        }
+
+        $response = Http::timeout(20)
+            ->acceptJson()
+            ->post('https://api.telegram.org/bot'.$token.'/'.$method, $params);
+
+        $body = $response->json();
+        if (! is_array($body) || ($body['ok'] ?? false) !== true) {
+            $description = is_array($body) ? (string) ($body['description'] ?? '') : '';
+            throw new RuntimeException($description !== '' ? $description : 'Telegram ha risposto con un errore.');
+        }
+
+        return $body;
+    }
+
+    public function sendMessage(int|string $chatId, string $text): void
+    {
+        $text = trim($text);
+        if ($text === '') {
+            return;
+        }
+        if (mb_strlen($text) > 4000) {
+            $text = mb_substr($text, 0, 3990).'…';
+        }
+
+        $this->call('sendMessage', [
+            'chat_id' => $chatId,
+            'text' => $text,
+        ]);
+    }
+
+    public function downloadFile(string $fileId): string
+    {
+        $body = $this->call('getFile', ['file_id' => $fileId]);
+        $path = (string) data_get($body, 'result.file_path', '');
+        if ($path === '') {
+            throw new RuntimeException('File Telegram non disponibile.');
+        }
+
+        $token = $this->token();
+        $response = Http::timeout(60)->get('https://api.telegram.org/file/bot'.$token.'/'.$path);
+        if (! $response->successful() || $response->body() === '') {
+            throw new RuntimeException('Download del vocale non riuscito.');
+        }
+
+        return $response->body();
+    }
+
+    public function setWebhook(string $url, string $secret): void
+    {
+        $this->call('setWebhook', [
+            'url' => $url,
+            'secret_token' => $secret,
+            'allowed_updates' => ['message'],
+        ]);
+    }
+}

app/Services/TelegramTaskIntake.php

@@ -0,0 +1,183 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Config;
+use App\Models\Task;
+use App\Support\TaskMessageParser;
+use Illuminate\Database\UniqueConstraintViolationException;
+use Illuminate\Support\Facades\Log;
+use Throwable;
+
+class TelegramTaskIntake
+{
+    public function __construct(
+        private TelegramBotService $telegram,
+        private AudioTranscriptionService $transcription,
+    ) {}
+
+    /**
+     * @param  array<string, mixed>  $update
+     */
+    public function handle(array $update): void
+    {
+        $message = $update['message'] ?? null;
+        if (! is_array($message)) {
+            return;
+        }
+
+        $chatId = data_get($message, 'chat.id');
+        $userId = (int) data_get($message, 'from.id', 0);
+        if ($chatId === null || $userId <= 0) {
+            return;
+        }
+
+        if (! $this->isAllowed($userId)) {
+            $this->reply($chatId, 'Accesso non abilitato. Comunica questo ID Telegram a chi gestisce MyAzienda: '.$userId);
+
+            return;
+        }
+
+        $updateId = isset($update['update_id']) ? (int) $update['update_id'] : 0;
+        if ($updateId > 0 && Task::query()->where('telegram_update_id', $updateId)->exists()) {
+            return;
+        }
+
+        $text = trim((string) ($message['text'] ?? ''));
+        $command = $this->command($text);
+        if ($command !== null) {
+            if (in_array($command['name'], ['start', 'help'], true) || $command['rest'] === '') {
+                $this->reply($chatId, $this->helpText());
+
+                return;
+            }
+            $text = $command['name'] === 'urgente' ? '! '.$command['rest'] : $command['rest'];
+        }
+
+        $audio = $message['voice'] ?? $message['audio'] ?? null;
+        if (is_array($audio) && isset($audio['file_id'])) {
+            try {
+                $binary = $this->telegram->downloadFile((string) $audio['file_id']);
+                $text = $this->transcription->transcribe($binary, isset($audio['mime_type']) ? (string) $audio['mime_type'] : null);
+            } catch (Throwable $e) {
+                Log::warning('Trascrizione task Telegram non riuscita', ['error' => $e->getMessage()]);
+                $this->reply($chatId, $e->getMessage());
+
+                return;
+            }
+        }
+
+        if ($text === '') {
+            return;
+        }
+
+        $text = preg_replace('/\b(?:hashtag|cancelletto)\s+/iu', '#', $text) ?? $text;
+        [$values, $alias] = $this->tipiParser();
+        $parsed = TaskMessageParser::parse($text, $values, $alias);
+        if ($parsed['testo'] === '') {
+            $this->reply($chatId, "Manca il testo del task.\n\n".$this->helpText());
+
+            return;
+        }
+
+        $task = new Task();
+        $task->testo = $parsed['testo'];
+        $task->settore = $parsed['settore'];
+        $task->tempo_stimato_minuti = $parsed['tempo_minuti'];
+        $task->prioritario = $parsed['prioritario'];
+        $task->origine = 'telegram';
+        $task->telegram_update_id = $updateId > 0 ? $updateId : null;
+
+        try {
+            $task->save();
+        } catch (UniqueConstraintViolationException) {
+            return;
+        }
+
+        $this->reply($chatId, $this->conferma($task));
+    }
+
+    private function isAllowed(int $userId): bool
+    {
+        $allowed = Config::telegramAllowedUserIds();
+
+        return $allowed !== [] && in_array($userId, $allowed, true);
+    }
+
+    /**
+     * @return array{name: string, rest: string}|null
+     */
+    private function command(string $text): ?array
+    {
+        if (! preg_match('/^\/(start|help|task|urgente)(?:@\S+)?(?:\s+([\s\S]*))?$/u', $text, $match)) {
+            return null;
+        }
+
+        return [
+            'name' => $match[1],
+            'rest' => trim((string) ($match[2] ?? '')),
+        ];
+    }
+
+    /**
+     * @return array{0: list<string>, 1: array<string, string>}
+     */
+    private function tipiParser(): array
+    {
+        $values = [];
+        $alias = [];
+        foreach (Config::tipiSegnalazione() as $tipo) {
+            $values[] = $tipo['value'];
+            $alias[$tipo['label']] = $tipo['value'];
+        }
+
+        return [$values, $alias];
+    }
+
+    private function helpText(): string
+    {
+        [$values] = $this->tipiParser();
+        $esempi = [];
+        foreach ($values as $value) {
+            $esempi[] = '#'.TaskMessageParser::slug($value);
+        }
+
+        $linee = [
+            'Inviami un testo o un vocale: lo salvo come cosa da fare.',
+            'Inizia con ! oppure con urgente per marcarlo prioritario.',
+        ];
+        if ($esempi !== []) {
+            $linee[] = 'Tipo: '.implode(', ', $esempi);
+        }
+        $linee[] = 'Tempo stimato: ~45m, ~1h30m oppure ~1,5';
+        $linee[] = 'Esempio: ! #manutenzione ~30m chiamare Rossi';
+
+        return implode("\n", $linee);
+    }
+
+    private function conferma(Task $task): string
+    {
+        $linee = ['Task #'.$task->id.' salvato.'];
+        if ($task->prioritario) {
+            $linee[] = 'Prioritario';
+        }
+        if ($task->settore) {
+            $linee[] = 'Tipo: '.Config::tipoSegnalazioneLabel($task->settore);
+        }
+        if ($task->tempo_stimato_minuti) {
+            $linee[] = 'Tempo: '.Config::formatTempo($task->tempo_stimato_minuti);
+        }
+        $linee[] = $task->testo;
+
+        return implode("\n", $linee);
+    }
+
+    private function reply(int|string $chatId, string $text): void
+    {
+        try {
+            $this->telegram->sendMessage($chatId, $text);
+        } catch (Throwable $e) {
+            Log::warning('Risposta Telegram non inviata', ['error' => $e->getMessage()]);
+        }
+    }
+}

app/Support/TaskMessageParser.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace App\Support;
+
+use App\Models\Config;
+
+class TaskMessageParser
+{
+    /**
+     * Ricava settore, priorità e tempo da un messaggio rapido.
+     *
+     * ! oppure la prima parola "urgente"/"prioritario" segnano il task come prioritario.
+     * #tipo assegna un tipo segnalazione. ~45m, ~1h30m o ~1,5 indicano il tempo stimato.
+     *
+     * @param  list<string>  $settori  valori canonici (il value del tipo)
+     * @param  array<string, string>  $alias  etichetta o sinonimo => value
+     * @return array{testo: string, settore: ?string, prioritario: bool, tempo_minuti: ?int}
+     */
+    public static function parse(string $raw, array $settori, array $alias = []): array
+    {
+        $settoriBySlug = [];
+        foreach ($settori as $value) {
+            $slug = self::slug((string) $value);
+            if ($slug !== '') {
+                $settoriBySlug[$slug] = (string) $value;
+            }
+        }
+        foreach ($alias as $from => $to) {
+            $to = (string) $to;
+            if (! in_array($to, $settori, true)) {
+                continue;
+            }
+            $slug = self::slug((string) $from);
+            if ($slug !== '') {
+                $settoriBySlug[$slug] = $to;
+            }
+        }
+
+        $state = [
+            'prioritario' => false,
+            'settore' => null,
+            'tempo_minuti' => null,
+        ];
+        $kept = [];
+        $isFirst = true;
+
+        foreach (preg_split('/\s+/u', trim($raw)) ?: [] as $token) {
+            if ($token === '') {
+                continue;
+            }
+
+            if ($isFirst && (strcasecmp($token, 'urgente') === 0 || strcasecmp($token, 'prioritario') === 0)) {
+                $state['prioritario'] = true;
+                $isFirst = false;
+                continue;
+            }
+            $isFirst = false;
+
+            $rest = self::peel($token, $state, $settoriBySlug);
+            if ($rest !== null && $rest !== '') {
+                $kept[] = $rest;
+            }
+        }
+
+        return [
+            'testo' => trim(implode(' ', $kept)),
+            'settore' => $state['settore'],
+            'prioritario' => $state['prioritario'],
+            'tempo_minuti' => $state['tempo_minuti'],
+        ];
+    }
+
+    public static function slug(string $value): string
+    {
+        $value = mb_strtolower(trim($value));
+        $value = strtr($value, [
+            'à' => 'a', 'á' => 'a', 'è' => 'e', 'é' => 'e', 'ì' => 'i', 'í' => 'i',
+            'ò' => 'o', 'ó' => 'o', 'ù' => 'u', 'ú' => 'u',
+        ]);
+
+        return preg_replace('/[^a-z0-9]+/u', '', $value) ?? '';
+    }
+
+    /**
+     * @param  array{prioritario: bool, settore: ?string, tempo_minuti: ?int}  $state
+     * @param  array<string, string>  $settoriBySlug
+     */
+    private static function peel(string $token, array &$state, array $settoriBySlug): ?string
+    {
+        $guard = 0;
+        while ($token !== '' && $guard++ < 6) {
+            if ($token === '!') {
+                $state['prioritario'] = true;
+
+                return null;
+            }
+
+            if (str_starts_with($token, '!')) {
+                $state['prioritario'] = true;
+                $token = mb_substr($token, 1);
+                continue;
+            }
+
+            if (str_starts_with($token, '#')) {
+                $hash = $token;
+                $gluedTime = null;
+                if (str_contains($token, '~')) {
+                    [$hash, $gluedTime] = explode('~', $token, 2);
+                }
+                $slug = self::slug(mb_substr($hash, 1));
+                if ($slug !== '' && isset($settoriBySlug[$slug])) {
+                    $state['settore'] = $settoriBySlug[$slug];
+                    if ($gluedTime === null) {
+                        return null;
+                    }
+                    $token = '~'.$gluedTime;
+                    continue;
+                }
+
+                return $token;
+            }
+
+            if (str_starts_with($token, '~') && mb_strlen($token) > 1) {
+                $parsed = Config::parseTempoToMinuti(mb_substr($token, 1));
+                if ($parsed !== null) {
+                    $state['tempo_minuti'] = $parsed;
+
+                    return null;
+                }
+
+                return $token;
+            }
+
+            return $token;
+        }
+
+        return $token !== '' ? $token : null;
+    }
+}

bootstrap/app.php

@@ -17,6 +17,9 @@ return Application::configure(basePath: dirname(__DIR__))
         $middleware->validateCsrfTokens(except: [
             'webhook/stripe/acquisto-servizio',
             'webhook/paypal/acquisto-servizio',
+            'webhook/stripe/shop',
+            'webhook/paypal/shop',
+            'webhook/telegram/tasks',
         ]);
     })
     ->withMiddleware(function (Middleware $middleware) {

config/services.php

@@ -83,6 +83,20 @@ return [
         'access_token' => env('FATTUREINCLOUD_ACCESS_TOKEN'),
     ],
 
+    /*
+    | Bot Telegram per creare task da testo o vocale.
+    | I valori salvati in Configurazione > Task hanno la precedenza.
+    */
+    'telegram' => [
+        'bot_token' => env('TELEGRAM_BOT_TOKEN'),
+        'webhook_secret' => env('TELEGRAM_WEBHOOK_SECRET'),
+    ],
+
+    'openai' => [
+        'api_key' => env('OPENAI_API_KEY'),
+        'transcribe_model' => env('OPENAI_TRANSCRIBE_MODEL', 'whisper-1'),
+    ],
+
     'skebby' => [
         'username' => env('SKEBBY_USERNAME'),
         'password' => env('SKEBBY_PASSWORD'),

database/migrations/2026_10_20_230000_create_task_table.php

@@ -0,0 +1,34 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('task', function (Blueprint $table) {
+            $table->bigIncrements('id');
+            $table->text('testo');
+            $table->string('settore')->nullable();
+            $table->unsignedInteger('tempo_stimato_minuti')->nullable();
+            $table->boolean('prioritario')->default(false);
+            $table->timestamp('completato_at')->nullable();
+            $table->unsignedBigInteger('segnalazione_id')->nullable();
+            $table->unsignedBigInteger('user_id')->nullable();
+            $table->string('origine')->default('web');
+            $table->unsignedBigInteger('telegram_update_id')->nullable();
+            $table->timestamps();
+
+            $table->index('completato_at');
+            $table->index('segnalazione_id');
+            $table->unique('telegram_update_id');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('task');
+    }
+};

resources/menu/verticalMenu.json

@@ -37,6 +37,13 @@
       "url": "admin/segnalazione",
       "can": "view-segnalazione|view-segnalazione-assegnate"
     },
+    {
+      "name": "Cose da fare",
+      "icon": "menu-icon icon-base bx bx-task",
+      "slug": "admin.task.index",
+      "url": "admin/tasks",
+      "can": "view-task"
+    },
     {
       "name": "Tempo Impiegato",
       "icon": "menu-icon icon-base bx bx-time",

resources/views/config/index.blade.php

@@ -7,6 +7,7 @@ $tabIcons = [
   'Acquisto servizio' => 'bx-cart',
   'Fatturazione' => 'bx-receipt',
   'Fatture in Cloud' => 'bx-cloud',
+  'Task' => 'bx-task',
 ];
 $groupKeys = array_keys($groups);
 $activeGroup = session('config_group');
@@ -151,6 +152,11 @@ if (is_string($activeGroup)) {
               </select>
               @break
 
+              @case('lines')
+              <textarea class="form-control" name="value[{{ $config->key }}]" id="{{ $fid }}-control" rows="6" {{ $disabled }}>{{ implode("\n", Config::decodeList($config->value)) }}</textarea>
+              <div class="form-text">Un valore per riga, nell'ordine in cui vuoi vederlo.</div>
+              @break
+
               @case('stato')
               <select class="form-select" name="value[{{ $config->key }}]" id="{{ $fid }}-control" {{ $disabled }}>
                 <option value="">— Seleziona —</option>
@@ -238,6 +244,15 @@ if (is_string($activeGroup)) {
               @if($config->key === Config::FIC_ACCESS_TOKEN)
               <div class="form-text">Token manuale di <a href="https://developers.fattureincloud.it/docs/getting-started/" target="_blank" rel="noopener">Fatture in Cloud</a> con scope <code>entity.clients:r</code>, <code>entity.clients:a</code>, <code>settings:r</code> e <code>issued_documents.invoices:a</code>. Lascia vuoto per non sostituirlo.</div>
               @endif
+              @if($config->key === Config::TELEGRAM_BOT_TOKEN)
+              <div class="form-text">Token di @BotFather. Salvalo, poi usa Collega bot Telegram. L'indirizzo dell'app deve essere pubblico e in HTTPS.</div>
+              @endif
+              @if($config->key === Config::TELEGRAM_WEBHOOK_SECRET)
+              <div class="form-text">Se lo lasci vuoto viene creato al collegamento del bot. Un valore già salvato non viene cancellato.</div>
+              @endif
+              @if($config->key === Config::OPENAI_API_KEY)
+              <div class="form-text">Serve per trascrivere i vocali inviati al bot. Lascia vuoto per non sostituirla.</div>
+              @endif
               @break
 
               @default
@@ -245,11 +260,25 @@ if (is_string($activeGroup)) {
               @if($config->key === Config::FIC_COMPANY_ID)
               <div class="form-text">Identificativo azienda su Fatture in Cloud. Si legge anche da Impostazioni → API, oppure con il metodo List User Companies.</div>
               @endif
+              @if($config->key === Config::TELEGRAM_ALLOWED_IDS)
+              <div class="form-text">ID numerici, separati da virgola o spazio. Se chi scrive non è in elenco, il bot risponde solo con il suo ID.</div>
+              @endif
+              @if($config->key === Config::OPENAI_TRANSCRIBE_MODEL)
+              <div class="form-text">Default <code>whisper-1</code>. Un messaggio può essere testo oppure audio: l'audio viene trascritto e poi salvato come task.</div>
+              @endif
             @endswitch
           </div>
           @empty
           <p class="text-muted mb-0">Nessuna impostazione in questo gruppo.</p>
           @endforelse
+          @if($group === 'Task' && $canEdit)
+          <div class="config-field">
+            <p class="mb-2">Collega il bot all'indirizzo pubblico HTTPS dell'app. Se hai appena incollato il token, questo pulsante lo salva prima di registrare il webhook.</p>
+            <button type="submit" class="btn btn-sm btn-outline-primary" formaction="{{ route('admin.config.telegram') }}">
+              <i class="bx bxl-telegram me-1"></i>Collega bot Telegram
+            </button>
+          </div>
+          @endif
         </div>
         @endforeach
       </div>

resources/views/dashboard/dashboards-manutenzioni.blade.php

@@ -18,6 +18,42 @@ $configData = Helper::appClasses();
 @endsection
 
 @section('content')
+@if(!empty($mostraTasks))
+<div class="card mb-4">
+  <div class="card-header border-bottom">
+    <div class="d-flex flex-column flex-md-row justify-content-between align-items-md-center gap-2">
+      <div class="d-flex align-items-center">
+        <div class="avatar avatar-sm me-2">
+          <span class="avatar-initial rounded bg-label-danger">
+            <i class="bx bx-task fs-4"></i>
+          </span>
+        </div>
+        <div>
+          <h5 class="mb-0">Cose da fare</h5>
+          <p class="text-body-secondary mb-0">I prioritari restano in alto, evidenziati in rosso</p>
+        </div>
+      </div>
+      <div class="d-flex flex-wrap gap-2">
+        <div class="btn-group btn-group-sm">
+          <a href="{{ route('admin.dashboard', ['vista' => 'inserimento']) }}" class="btn {{ ($tasksVista ?? 'inserimento') === 'inserimento' ? 'btn-primary' : 'btn-outline-primary' }}">Ordine di inserimento</a>
+          <a href="{{ route('admin.dashboard', ['vista' => 'settore']) }}" class="btn {{ ($tasksVista ?? '') === 'settore' ? 'btn-primary' : 'btn-outline-primary' }}">Per tipo</a>
+        </div>
+        @can('view-task')
+        <a href="{{ route('admin.task.index', ['vista' => $tasksVista ?? 'inserimento']) }}" class="btn btn-sm btn-label-primary">Gestisci</a>
+        @endcan
+      </div>
+    </div>
+  </div>
+  <div class="card-body p-0">
+    @include('task._elenco', [
+      'presentazione' => $tasksPresentazione,
+      'gestione' => false,
+      'vista' => $tasksVista ?? 'inserimento',
+    ])
+  </div>
+</div>
+@endif
+
 <div class="card mb-4">
   <div class="card-header border-bottom">
     <div class="d-flex align-items-center">
@@ -390,6 +426,10 @@ $configData = Helper::appClasses();
   #calendarioSlotPrenotazioni .fc-event {
     border: none;
   }
+  .task-prioritario {
+    background: rgba(220, 53, 69, 0.08);
+    box-shadow: inset 4px 0 0 #dc3545;
+  }
 </style>
 @endsection
 

resources/views/task/_elenco.blade.php

@@ -0,0 +1,23 @@
+@php
+  $prioritari = $presentazione['prioritari'] ?? collect();
+  $sezioni = $presentazione['sezioni'] ?? [];
+  $vuoto = $prioritari->isEmpty() && collect($sezioni)->every(fn ($sezione) => ($sezione['tasks'] ?? collect())->isEmpty());
+@endphp
+
+@if($vuoto)
+<div class="p-4 text-center text-muted">Nessun task in questo elenco.</div>
+@else
+  @if($prioritari->isNotEmpty())
+  <div class="px-4 pt-3 pb-1 small text-danger fw-semibold text-uppercase">Prioritari</div>
+  @include('task._riga', ['righe' => $prioritari, 'gestione' => $gestione ?? false, 'canEdit' => $canEdit ?? false, 'canDelete' => $canDelete ?? false, 'stato' => $stato ?? 'aperte', 'vista' => $vista ?? 'inserimento'])
+  @endif
+
+  @foreach($sezioni as $sezione)
+    @if(($sezione['tasks'] ?? collect())->isNotEmpty())
+      @if(!empty($sezione['label']))
+      <div class="px-4 pt-3 pb-1 small text-muted fw-semibold text-uppercase">{{ $sezione['label'] }}</div>
+      @endif
+      @include('task._riga', ['righe' => $sezione['tasks'], 'gestione' => $gestione ?? false, 'canEdit' => $canEdit ?? false, 'canDelete' => $canDelete ?? false, 'stato' => $stato ?? 'aperte', 'vista' => $vista ?? 'inserimento'])
+    @endif
+  @endforeach
+@endif

resources/views/task/_riga.blade.php

@@ -0,0 +1,60 @@
+@php
+  $righe = $righe ?? collect();
+@endphp
+@foreach($righe as $task)
+@php
+  $fatto = $task->isCompletato();
+@endphp
+<div class="d-flex flex-column flex-md-row align-items-md-center justify-content-between gap-2 px-4 py-3 border-bottom {{ $task->prioritario ? 'task-prioritario' : '' }}">
+  <div class="min-w-0">
+    <div class="task-testo {{ $fatto ? 'text-decoration-line-through text-muted' : '' }}">
+      @if($task->prioritario)
+      <i class="bx bx-error-circle me-1"></i>
+      @endif
+      @if(($gestione ?? false) && ($canEdit ?? false))
+      <a href="{{ route('admin.task.edit', ['id' => $task->id, 'stato' => $stato ?? 'aperte', 'vista' => $vista ?? 'inserimento']) }}" class="{{ $task->prioritario && ! $fatto ? 'text-danger' : 'text-body' }}">{{ $task->testo }}</a>
+      @else
+      <span class="{{ $task->prioritario && ! $fatto ? 'text-danger fw-semibold' : '' }}">{{ $task->testo }}</span>
+      @endif
+    </div>
+    <div class="small mt-1 d-flex flex-wrap align-items-center gap-1">
+      @if($task->settore)
+      <span class="badge bg-label-primary">{{ ($tipoLabels ?? [])[$task->settore] ?? $task->settore }}</span>
+      @endif
+      @if($task->tempo_stimato_minuti)
+      <span class="badge bg-label-secondary">{{ \App\Models\Config::formatTempo($task->tempo_stimato_minuti) }}</span>
+      @endif
+      @if($task->prioritario)
+      <span class="badge bg-danger">Prioritario</span>
+      @endif
+      @if($task->origine === 'telegram')
+      <span class="badge bg-label-info" title="Creato da Telegram"><i class="bx bxl-telegram"></i> Telegram</span>
+      @endif
+      @if($task->segnalazione)
+      <a href="{{ route('admin.segnalazione.show', ['id' => $task->segnalazione->id]) }}" class="badge bg-label-warning text-decoration-none">{{ $task->segnalazione->getLabel() }}</a>
+      @endif
+      <span class="text-muted">{{ $task->created_at?->format('d/m/Y H:i') }}</span>
+    </div>
+  </div>
+  @if($gestione ?? false)
+  <div class="d-flex flex-wrap gap-1 flex-shrink-0">
+    @if($canEdit ?? false)
+    <form method="POST" action="{{ route('admin.task.toggle', $task->id) }}">
+      @csrf
+      <button type="submit" class="btn btn-sm {{ $fatto ? 'btn-label-secondary' : 'btn-label-success' }}">
+        <i class="bx {{ $fatto ? 'bx-undo' : 'bx-check' }} me-1"></i>{{ $fatto ? 'Riapri' : 'Fatto' }}
+      </button>
+    </form>
+    <a href="{{ route('admin.task.edit', ['id' => $task->id, 'stato' => $stato ?? 'aperte', 'vista' => $vista ?? 'inserimento']) }}" class="btn btn-sm btn-label-primary">Modifica</a>
+    @endif
+    @if($canDelete ?? false)
+    <form method="POST" action="{{ route('admin.task.destroy', $task->id) }}" onsubmit="return confirm('Eliminare questo task?')">
+      @csrf
+      @method('DELETE')
+      <button type="submit" class="btn btn-sm btn-label-danger">Elimina</button>
+    </form>
+    @endif
+  </div>
+  @endif
+</div>
+@endforeach

resources/views/task/index.blade.php

@@ -0,0 +1,224 @@
+@php
+$configData = Helper::appClasses();
+$mode = old('segnalazione_mode', $task->exists && $task->segnalazione_id ? 'esistente' : 'nessuna');
+$tempoValue = old('tempo', $task->tempo_stimato_minuti ? \App\Models\Config::formatTempo($task->tempo_stimato_minuti) : '');
+$prioritarioVal = old('prioritario', $task->prioritario);
+$prioritarioChecked = $prioritarioVal === true || $prioritarioVal === 1 || $prioritarioVal === '1';
+@endphp
+
+@extends('layouts/layoutMaster')
+
+@section('title', 'Cose da fare')
+
+@section('pageTitle')
+<div class="d-flex flex-column flex-md-row justify-content-between align-items-md-center gap-2">
+  <h4 class="mb-0">Cose da fare</h4>
+  <div class="btn-group btn-group-sm">
+    <a href="{{ route('admin.task.index', ['vista' => 'inserimento', 'stato' => $stato]) }}" class="btn {{ $vista === 'inserimento' ? 'btn-primary' : 'btn-outline-primary' }}">Ordine di inserimento</a>
+    <a href="{{ route('admin.task.index', ['vista' => 'settore', 'stato' => $stato]) }}" class="btn {{ $vista === 'settore' ? 'btn-primary' : 'btn-outline-primary' }}">Per tipo</a>
+  </div>
+</div>
+@endsection
+
+@section('content')
+<style>
+  .task-prioritario {
+    background: rgba(220, 53, 69, 0.08);
+    box-shadow: inset 4px 0 0 #dc3545;
+  }
+</style>
+
+@if(session('success'))
+<div class="alert alert-success alert-dismissible fade show" role="alert">
+  {{ session('success') }}
+  <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
+</div>
+@endif
+
+@if($errors->any())
+<div class="alert alert-danger">
+  <ul class="mb-0">
+    @foreach($errors->all() as $error)
+    <li>{{ $error }}</li>
+    @endforeach
+  </ul>
+</div>
+@endif
+
+@if($canCreate || $task->exists)
+<div class="card mb-4">
+  <div class="card-header border-bottom">
+    <h5 class="mb-0">{{ $task->exists ? 'Modifica task' : 'Nuovo task' }}</h5>
+  </div>
+  <div class="card-body">
+    <form method="POST" action="{{ $task->exists ? route('admin.task.update', $task->id) : route('admin.task.store') }}">
+      @csrf
+      @if($task->exists) @method('PUT') @endif
+      <div class="row g-3">
+        <div class="col-12">
+          <label class="form-label" for="task-testo">Cosa c'è da fare <span class="text-danger">*</span></label>
+          <textarea class="form-control" id="task-testo" name="testo" rows="3" required>{{ old('testo', $task->testo) }}</textarea>
+        </div>
+        <div class="col-md-4">
+          <label class="form-label" for="task-settore">Tipo</label>
+          <select class="form-select" id="task-settore" name="settore">
+            <option value="">— Nessuno —</option>
+            @foreach($tipi as $tipo)
+            <option value="{{ $tipo['value'] }}" @selected(old('settore', $task->settore) === $tipo['value'])>{{ $tipo['label'] }}</option>
+            @endforeach
+            @if($task->settore && ! in_array($task->settore, $settori, true))
+            <option value="{{ $task->settore }}" selected>{{ $tipoLabels[$task->settore] ?? $task->settore }}</option>
+            @endif
+          </select>
+          <div class="form-text">Stesso tipo delle segnalazioni. Se colleghi o crei una segnalazione, il tipo resta allineato.</div>
+        </div>
+        <div class="col-md-4">
+          <label class="form-label" for="task-tempo">Tempo stimato</label>
+          <input type="text" class="form-control" id="task-tempo" name="tempo" value="{{ $tempoValue }}" placeholder="45m, 1h30m, 1,5">
+        </div>
+        <div class="col-md-4 d-flex align-items-end">
+          <div class="form-check mb-2">
+            <input type="hidden" name="prioritario" value="0">
+            <input class="form-check-input" type="checkbox" name="prioritario" id="task-prioritario" value="1" @checked($prioritarioChecked)>
+            <label class="form-check-label text-danger fw-semibold" for="task-prioritario">Prioritario</label>
+          </div>
+        </div>
+        <div class="col-12">
+          <label class="form-label d-block">Segnalazione</label>
+          <div class="d-flex flex-wrap gap-3">
+            <div class="form-check">
+              <input class="form-check-input" type="radio" name="segnalazione_mode" id="mode-nessuna" value="nessuna" @checked($mode === 'nessuna')>
+              <label class="form-check-label" for="mode-nessuna">Nessuna</label>
+            </div>
+            <div class="form-check">
+              <input class="form-check-input" type="radio" name="segnalazione_mode" id="mode-esistente" value="esistente" @checked($mode === 'esistente')>
+              <label class="form-check-label" for="mode-esistente">Collega una esistente</label>
+            </div>
+            @if($puoCreareSegnalazione)
+            <div class="form-check">
+              <input class="form-check-input" type="radio" name="segnalazione_mode" id="mode-nuova" value="nuova" @checked($mode === 'nuova')>
+              <label class="form-check-label" for="mode-nuova">Creane una nuova</label>
+            </div>
+            @endif
+          </div>
+        </div>
+        <div class="col-12 {{ $mode === 'esistente' ? '' : 'd-none' }}" id="task-esistente">
+          <label class="form-label" for="task-cerca-segnalazione">Cerca segnalazione</label>
+          <input type="hidden" name="segnalazione_id" id="task-segnalazione-id" value="{{ old('segnalazione_id', $task->segnalazione_id) }}">
+          <input type="text" class="form-control" id="task-cerca-segnalazione" autocomplete="off" placeholder="Numero o titolo" value="{{ $segnalazioneSelezionata ? $segnalazioneSelezionata->getLabel() : '' }}">
+          <div class="list-group mt-1 d-none" id="task-segnalazione-risultati"></div>
+        </div>
+        <div class="col-12 {{ $mode === 'nuova' ? '' : 'd-none' }}" id="task-nuova">
+          <label class="form-label" for="task-titolo-segnalazione">Titolo della nuova segnalazione</label>
+          <input type="text" class="form-control" id="task-titolo-segnalazione" name="nuova_segnalazione_titolo" maxlength="255" value="{{ old('nuova_segnalazione_titolo') }}" placeholder="Se lo lasci vuoto uso il testo del task">
+          <div class="form-text">La segnalazione nasce interna, senza notifica al cliente.</div>
+        </div>
+        <div class="col-12 d-flex flex-wrap gap-2">
+          <button type="submit" class="btn btn-primary">
+            <i class="bx bx-save me-1"></i>{{ $task->exists ? 'Salva modifiche' : 'Aggiungi' }}
+          </button>
+          @if($task->exists)
+          <a href="{{ route('admin.task.index', ['vista' => $vista, 'stato' => $stato]) }}" class="btn btn-label-secondary">Annulla</a>
+          @endif
+        </div>
+      </div>
+    </form>
+    @if(! $task->exists)
+    <p class="text-muted small mb-0 mt-3">
+      Da Telegram puoi mandare un testo o un vocale.
+      @can('view-config')
+      Il bot si collega da <a href="{{ route('admin.config.index') }}">Configurazione</a>, gruppo Task.
+      @endcan
+    </p>
+    @endif
+  </div>
+</div>
+@endif
+
+<div class="card mb-4">
+  <div class="card-header border-bottom d-flex flex-wrap justify-content-between align-items-center gap-2">
+    <div>
+      <h5 class="mb-0">Elenco</h5>
+      <p class="text-body-secondary mb-0">{{ $totale }} {{ $totale === 1 ? 'task' : 'task' }} · i prioritari restano in alto, in rosso</p>
+    </div>
+    <div class="btn-group btn-group-sm">
+      @foreach(['aperte' => 'Aperti', 'completate' => 'Fatti', 'tutte' => 'Tutti'] as $key => $label)
+      <a href="{{ route('admin.task.index', ['stato' => $key, 'vista' => $vista]) }}" class="btn {{ $stato === $key ? 'btn-primary' : 'btn-outline-primary' }}">{{ $label }}</a>
+      @endforeach
+    </div>
+  </div>
+  <div class="card-body p-0">
+    @include('task._elenco', [
+      'presentazione' => $presentazione,
+      'gestione' => true,
+      'canEdit' => $canEdit,
+      'canDelete' => $canDelete,
+      'stato' => $stato,
+      'vista' => $vista,
+    ])
+  </div>
+</div>
+@endsection
+
+@section('page-script')
+<script>
+(function () {
+  var radios = document.querySelectorAll('input[name="segnalazione_mode"]');
+  var esistente = document.getElementById('task-esistente');
+  var nuova = document.getElementById('task-nuova');
+  function syncMode() {
+    var selected = document.querySelector('input[name="segnalazione_mode"]:checked');
+    var mode = selected ? selected.value : 'nessuna';
+    if (esistente) esistente.classList.toggle('d-none', mode !== 'esistente');
+    if (nuova) nuova.classList.toggle('d-none', mode !== 'nuova');
+  }
+  radios.forEach(function (radio) { radio.addEventListener('change', syncMode); });
+  syncMode();
+
+  var input = document.getElementById('task-cerca-segnalazione');
+  var hidden = document.getElementById('task-segnalazione-id');
+  var risultati = document.getElementById('task-segnalazione-risultati');
+  if (!input || !hidden || !risultati) return;
+
+  var timer = null;
+  input.addEventListener('input', function () {
+    hidden.value = '';
+    clearTimeout(timer);
+    var q = input.value.trim();
+    if (q.length < 1) {
+      risultati.classList.add('d-none');
+      risultati.innerHTML = '';
+      return;
+    }
+    timer = setTimeout(function () {
+      fetch(@json(route('admin.task.segnalazioni')) + '?q=' + encodeURIComponent(q), {
+        headers: { 'Accept': 'application/json' }
+      }).then(function (response) { return response.json(); }).then(function (rows) {
+        risultati.innerHTML = '';
+        if (!rows.length) {
+          risultati.classList.add('d-none');
+          return;
+        }
+        rows.forEach(function (row) {
+          var button = document.createElement('button');
+          button.type = 'button';
+          button.className = 'list-group-item list-group-item-action';
+          button.textContent = row.label;
+          button.addEventListener('click', function () {
+            hidden.value = row.id;
+            input.value = row.label;
+            var tipo = document.getElementById('task-settore');
+            if (tipo && row.tipo) tipo.value = row.tipo;
+            risultati.classList.add('d-none');
+          });
+          risultati.appendChild(button);
+        });
+        risultati.classList.remove('d-none');
+      }).catch(function () {
+        risultati.classList.add('d-none');
+      });
+    }, 250);
+  });
+})();
+</script>
+@endsection

routes/web.php

@@ -14,6 +14,7 @@ use App\Http\Controllers\NazioneController;
 use App\Http\Controllers\RolePermissionsController;
 use App\Http\Controllers\SegnalazioneClienteController;
 use App\Http\Controllers\SegnalazioneController;
+use App\Http\Controllers\TelegramTaskController;
 use App\Http\Controllers\TempoImpiegatoController;
 use App\Http\Controllers\UserController;
 use App\Http\Controllers\AziendaController;
@@ -31,6 +32,7 @@ use App\Http\Controllers\AcquistoServizioOperatoreController;
 use App\Http\Controllers\AcquistoServizioFirmaController;
 use App\Http\Controllers\SegnalazioneRapportoFirmaController;
 use App\Http\Controllers\ShortUrlController;
+use App\Http\Controllers\TaskController;
 use Illuminate\Support\Facades\Route;
 
 Route::get('/', [HomePageController::class, 'welcome'])->name('welcome');
@@ -171,6 +173,15 @@ Route::middleware(['auth:sanctum', config('jetstream.auth_session')])->prefix('a
     Route::post('segnalazione/{id}/pdf/invia', [SegnalazioneController::class, 'admin_pdf_invia'])->name('admin.segnalazione.pdf.invia');
     Route::get('segnalazione/{id}/annotazione/{annotazione}/rapportino', [SegnalazioneController::class, 'admin_rapportino_annotazione'])->name('admin.segnalazione.annotazione.rapportino');
 
+    // Cose da fare
+    Route::get('tasks', [TaskController::class, 'admin_index'])->name('admin.task.index');
+    Route::post('tasks', [TaskController::class, 'admin_store'])->name('admin.task.store');
+    Route::get('tasks/segnalazioni', [TaskController::class, 'admin_segnalazioni'])->name('admin.task.segnalazioni');
+    Route::get('tasks/{id}/edit', [TaskController::class, 'admin_edit'])->name('admin.task.edit')->whereNumber('id');
+    Route::put('tasks/{id}', [TaskController::class, 'admin_update'])->name('admin.task.update')->whereNumber('id');
+    Route::post('tasks/{id}/toggle', [TaskController::class, 'admin_toggle'])->name('admin.task.toggle')->whereNumber('id');
+    Route::delete('tasks/{id}', [TaskController::class, 'admin_destroy'])->name('admin.task.destroy')->whereNumber('id');
+
     // Dashboard
     Route::get('dashboard', [HomePageController::class, 'admin_dashboard'])->name('admin.dashboard');
     Route::get('statistiche', [HomePageController::class, 'admin_statistiche'])->name('admin.statistiche');
@@ -190,6 +201,7 @@ Route::middleware(['auth:sanctum', config('jetstream.auth_session')])->prefix('a
     Route::get('config', [ConfigController::class, 'admin_index'])->name('admin.config.index');
     Route::post('config', [ConfigController::class, 'admin_save'])->name('admin.config.save');
     Route::post('config/fic-aliquote', [ConfigController::class, 'admin_sync_aliquote'])->name('admin.config.fic_aliquote');
+    Route::post('config/telegram', [ConfigController::class, 'admin_telegram_webhook'])->name('admin.config.telegram');
 
     // Configura Segnalazione
     Route::get('configura-segnalazione', [ConfiguraSegnalazioneController::class, 'admin_index'])->name('admin.configura-segnalazione.index');
@@ -281,6 +293,7 @@ Route::post('shop/firma-riconsegna/{token}', [AcquistoServizioFirmaController::c
 Route::get('shop/paypal/return/{token}', [AcquistoServizioPublicController::class, 'paypalReturn'])->name('shop.paypal.return');
 Route::post('webhook/stripe/shop', [AcquistoServizioPublicController::class, 'stripeWebhook'])->name('shop.webhook.stripe');
 Route::post('webhook/paypal/shop', [AcquistoServizioPublicController::class, 'paypalWebhook'])->name('shop.webhook.paypal');
+Route::post('webhook/telegram/tasks', [TelegramTaskController::class, 'webhook'])->name('telegram.task.webhook');
 
 // Alias legacy acquisto-servizio → shop
 Route::redirect('acquisto-servizio', '/shop', 301);

tests/Unit/TaskMessageParserTest.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Tests\Unit;
+
+use App\Models\Task;
+use App\Support\TaskMessageParser;
+use Illuminate\Support\Collection;
+use PHPUnit\Framework\TestCase;
+
+class TaskMessageParserTest extends TestCase
+{
+    /** @var list<string> */
+    private array $settori = ['Tecnico', 'Sviluppatore', 'Personale', 'Commerciale', 'Amministrativo'];
+
+    public function test_plain_text_stays_a_task(): void
+    {
+        $parsed = TaskMessageParser::parse('Chiamare Rossi per il preventivo', $this->settori);
+
+        $this->assertSame('Chiamare Rossi per il preventivo', $parsed['testo']);
+        $this->assertFalse($parsed['prioritario']);
+        $this->assertNull($parsed['settore']);
+        $this->assertNull($parsed['tempo_minuti']);
+    }
+
+    public function test_markers_set_priority_sector_and_time(): void
+    {
+        $parsed = TaskMessageParser::parse('! #sviluppatore ~1h30m sistemare export fatture', $this->settori);
+
+        $this->assertSame('sistemare export fatture', $parsed['testo']);
+        $this->assertTrue($parsed['prioritario']);
+        $this->assertSame('Sviluppatore', $parsed['settore']);
+        $this->assertSame(90, $parsed['tempo_minuti']);
+    }
+
+    public function test_glued_markers_and_decimal_hours(): void
+    {
+        $parsed = TaskMessageParser::parse('!#personale~1,5 aggiornare turni', $this->settori);
+
+        $this->assertSame('aggiornare turni', $parsed['testo']);
+        $this->assertTrue($parsed['prioritario']);
+        $this->assertSame('Personale', $parsed['settore']);
+        $this->assertSame(90, $parsed['tempo_minuti']);
+    }
+
+    public function test_urgente_counts_only_as_first_word(): void
+    {
+        $flagged = TaskMessageParser::parse('urgente richiamare il cliente', $this->settori);
+        $this->assertTrue($flagged['prioritario']);
+        $this->assertSame('richiamare il cliente', $flagged['testo']);
+
+        $plain = TaskMessageParser::parse('richiamare il cliente urgente', $this->settori);
+        $this->assertFalse($plain['prioritario']);
+        $this->assertSame('richiamare il cliente urgente', $plain['testo']);
+    }
+
+    public function test_label_alias_stores_the_tipo_value(): void
+    {
+        $parsed = TaskMessageParser::parse(
+            '#manutenzione controllare la caldaia',
+            ['manutenzione', 'sicurezza'],
+            ['Manutenzione' => 'manutenzione', 'Sicurezza' => 'sicurezza']
+        );
+
+        $this->assertSame('manutenzione', $parsed['settore']);
+        $this->assertSame('controllare la caldaia', $parsed['testo']);
+    }
+
+    public function test_unknown_sector_stays_in_the_text(): void
+    {
+        $parsed = TaskMessageParser::parse('#magazzino controllare lo stock', $this->settori);
+
+        $this->assertNull($parsed['settore']);
+        $this->assertSame('#magazzino controllare lo stock', $parsed['testo']);
+    }
+
+    public function test_priority_tasks_stay_on_top_in_both_views(): void
+    {
+        $tasks = new Collection([
+            $this->task(1, 'Secondo', 'Tecnico', false),
+            $this->task(2, 'Prima cosa', 'Commerciale', true),
+            $this->task(3, 'Terzo', 'Tecnico', false),
+            $this->task(4, 'Altro urgente', null, true),
+            $this->task(5, 'Senza gruppo', null, false),
+        ]);
+
+        $perInserimento = Task::presenta($tasks, 'inserimento', $this->settori);
+        $this->assertSame([2, 4], $perInserimento['prioritari']->pluck('id')->all());
+        $this->assertSame([1, 3, 5], $perInserimento['sezioni'][0]['tasks']->pluck('id')->all());
+
+        $perSettore = Task::presenta($tasks, 'settore', $this->settori);
+        $this->assertSame([2, 4], $perSettore['prioritari']->pluck('id')->all());
+        $this->assertSame('Tecnico', $perSettore['sezioni'][0]['label']);
+        $this->assertSame([1, 3], $perSettore['sezioni'][0]['tasks']->pluck('id')->all());
+        $this->assertSame('Senza tipo', $perSettore['sezioni'][1]['label']);
+        $this->assertSame([5], $perSettore['sezioni'][1]['tasks']->pluck('id')->all());
+
+        $conEtichette = Task::presenta($tasks, 'settore', $this->settori, ['Tecnico' => 'Manutenzione']);
+        $this->assertSame('Manutenzione', $conEtichette['sezioni'][0]['label']);
+    }
+
+    private function task(int $id, string $testo, ?string $settore, bool $prioritario): Task
+    {
+        $task = new Task([
+            'testo' => $testo,
+            'settore' => $settore,
+            'prioritario' => $prioritario,
+        ]);
+        $task->id = $id;
+
+        return $task;
+    }
+}