Finish v1.2.3(9)

Con il permesso negato "Aggiungi una foto" non faceva nulla: il servizio
restituiva null come per un annullamento. Dopo un rifiuto definitivo
Android non ripropone la richiesta, quindi il rilevatore restava bloccato
senza capire perche'.

- AttachedService: la richiesta dei permessi diventa RequestCameraPermissions,
  usata anche da SelectImageFromCamera; OpenAppSettings apre le impostazioni
  dell'app.
- ModalFormScheda e ModalAddAttached: chiedono i permessi prima di scattare
  e, se negati, mostrano un avviso con l'azione "Impostazioni".

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

SteUp.Data/LocalDb/EntityServices/IspezioniService.cs

@@ -155,14 +155,29 @@ public class IspezioniService(AppDbContext db) : IIspezioniService
         await db.SaveChangesAsync();
     }
 
-    public Task<List<Scheda>> GetAllSchedeOfIspezioneAsync(string codMdep, DateTime data, string rilevatore) =>
-        db.Schede
+    public async Task<List<Scheda>> GetAllSchedeOfIspezioneAsync(string codMdep, DateTime data, string rilevatore)
+    {
+        // Le versioni precedenti dell'app hanno lasciato schede non bozza senza
+        // reparto o motivo: risultano inviabili ma il server le rifiuta, e
+        // bloccano la conclusione dell'ispezione. Tornano bozze, cosi' il
+        // rilevatore le completa. Quelle gia' inviate non si toccano.
+        await db.Schede
+            .Where(x => x.CodMdep == codMdep &&
+                        x.Data == data &&
+                        x.Rilevatore == rilevatore &&
+                        !x.Bozza &&
+                        x.ActivityId == null &&
+                        (string.IsNullOrEmpty(x.CodJfas) || string.IsNullOrEmpty(x.ActivityTypeId)))
+            .ExecuteUpdateAsync(s => s.SetProperty(x => x.Bozza, true));
+
+        return await db.Schede
             .AsNoTracking()
             .Include(s => s.Articoli)
             .Where(x => x.CodMdep == codMdep &&
                         x.Data == data &&
                         x.Rilevatore == rilevatore)
             .ToListAsync();
+    }
 
     public Task<Scheda?> GetSchedaAsync(int schedaId) =>
         db.Schede

SteUp.Maui/Core/Services/AttachedService.cs

@@ -8,12 +8,21 @@ namespace SteUp.Maui.Core.Services;
 
 public class AttachedService(ILogger<FileManager> logger) : IAttachedService
 {
-    public async Task<AttachedDto?> SelectImageFromCamera()
+    public bool IsCameraAvailable => MediaPicker.Default.IsCaptureSupported;
+
+    public async Task<bool> RequestCameraPermissions()
     {
         var cameraPerm = await Permissions.RequestAsync<Permissions.Camera>();
         var storagePerm = await Permissions.RequestAsync<Permissions.StorageWrite>();
 
-        if (cameraPerm != PermissionStatus.Granted || storagePerm != PermissionStatus.Granted)
+        return cameraPerm == PermissionStatus.Granted && storagePerm == PermissionStatus.Granted;
+    }
+
+    public void OpenAppSettings() => AppInfo.Current.ShowSettingsUI();
+
+    public async Task<AttachedDto?> SelectImageFromCamera()
+    {
+        if (!await RequestCameraPermissions())
             return null;
 
         FileResult? result;
@@ -28,7 +37,10 @@ public class AttachedService(ILogger<FileManager> logger) : IAttachedService
             logger.LogError(ex, ex.Message);
             Console.WriteLine($"Errore cattura foto: {ex.Message}");
             SentrySdk.CaptureException(ex);
-            return null;
+
+            // Rilancia: restituire null qui era indistinguibile da un annullamento,
+            // e il rilevatore toccava "Aggiungi una foto" senza vedere nulla.
+            throw;
         }
 
         return result is null ? null : await UtilityFile.ConvertToDto(result, AttachedDto.TypeAttached.Image);

SteUp.Maui/Core/Services/FileManager.cs

@@ -1,5 +1,4 @@
-using System.IO.Compression;
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using SteUp.Data.LocalDb;
 using SteUp.Shared.Core.Dto;
 using SteUp.Shared.Core.Entities;
@@ -343,146 +342,57 @@ public class FileManager(
     private static string GetInspectionKey(Ispezione ispezione) =>
         $"{ispezione.CodMdep}_{ispezione.Data:ddMMyyyy}_{ispezione.Rilevatore.ToLower()}";
     
-    public List<SendEmailDto.AttachmentsDto> GetFileForExport()
+    public Task<long> GetLogExportImagesSizeAsync(CancellationToken ct = default) =>
+        Task.Run(() => RetrieveAttachedImages().Sum(x => x.File.Length), ct);
+
+    public Task<ILogExport> PrepareLogExportAsync(bool includeImages, CancellationToken ct = default)
     {
-        var attachments = new List<SendEmailDto.AttachmentsDto>();
-
-        // 1) log file singolo (se ti serve ancora)
-        var logFile = RetrieveLogFile();
-        if (!logFile.IsNullOrEmpty())
+        return Task.Run<ILogExport>(() =>
         {
-            attachments.Add(new SendEmailDto.AttachmentsDto
-            {
-                FileName = $"logs_{DateTime.Today:yyyyMMdd}.zip",
-                FileContent = CreateZipBytes(logFile!)
-            });
-        }
+            var workDir = Path.Combine(FileSystem.CacheDirectory, "log_export");
 
-        // 2) database zip
-        var dbZip = CreateDatabaseZipAttachment();
-        if (dbZip != null) attachments.Add(dbZip);
+            // Residui di un invio interrotto (app chiusa a metà): si riparte da zero.
+            if (Directory.Exists(workDir))
+                Directory.Delete(workDir, true);
+            Directory.CreateDirectory(workDir);
 
-        // 3) Img zip
-        var attachedInfo = new DirectoryInfo(Path.Combine(FileSystem.AppDataDirectory, "attached"));
-        if (!attachedInfo.Exists) return attachments;
-        
-        var attachedFiles = attachedInfo
-            .EnumerateFiles("*", SearchOption.AllDirectories)
+            var logFiles = RetrieveLogFiles()
+                .Select(f => new LogExport.ZipItem(f, f.Name))
                 .ToList();
 
-        if (attachedFiles.Count > 0)
-        {
-            attachments.Add(new SendEmailDto.AttachmentsDto
-            {
-                FileName = $"immagini_allegate_{DateTime.Today:yyyyMMdd}.zip",
-                FileContent = CreateZipBytes(attachedInfo.FullName, attachedFiles)
-            });
+            // Col journal WAL le modifiche recenti stanno ancora nel file -wal: senza, il database
+            // inviato può non avere le ultime ispezioni.
+            var dbPath = dbPathProvider.GetDbPath();
+            var dbFiles = new[] { dbPath, $"{dbPath}-wal" }
+                .Select(p => new FileInfo(p))
+                .Where(f => f.Exists)
+                .Select(f => new LogExport.ZipItem(f, f.Name))
+                .ToList();
+
+            var images = includeImages ? RetrieveAttachedImages() : [];
+
+            return new LogExport(workDir, logFiles, dbFiles, images, logger);
+        }, ct);
     }
 
-        return attachments;
+    private static List<FileInfo> RetrieveLogFiles()
+    {
+        var directory = new DirectoryInfo(Path.Combine(FileSystem.AppDataDirectory, "logs"));
+        return directory.Exists ? directory.GetFiles().ToList() : [];
     }
 
-    private static List<FileInfo>? RetrieveLogFile()
+    private static List<LogExport.ZipItem> RetrieveAttachedImages()
     {
-        var appDataPath = FileSystem.AppDataDirectory;
-        var targetDirectory = Path.Combine(appDataPath, "logs");
+        var root = new DirectoryInfo(Path.Combine(FileSystem.AppDataDirectory, "attached"));
+        if (!root.Exists) return [];
 
-        var directory = new DirectoryInfo(targetDirectory);
-
-        List<FileInfo>? files = null;
-
-        if (directory.Exists)
-            files = directory.GetFiles().ToList();
-
-        return files;
-    }
-    
-    private SendEmailDto.AttachmentsDto? CreateDatabaseZipAttachment()
-    {
-        var files = new[]
-        {
-            new FileInfo(dbPathProvider.GetDbPath())
-        };
-
-        // Filtra solo quelli esistenti
-        var existingFiles = files.Where(f => f.Exists).ToList();
-
-        if (existingFiles.Count == 0)
-            return null;
-
-        using var memoryStream = new MemoryStream();
-
-        using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
-        {
-            foreach (var file in existingFiles)
-            {
-                var entry = archive.CreateEntry(file.Name, CompressionLevel.Optimal);
-
-                using var entryStream = entry.Open();
-                using var fileStream = file.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-
-                fileStream.CopyTo(entryStream);
-            }
-        }
-
-        return new SendEmailDto.AttachmentsDto
-        {
-            FileName = $"database_{DateTime.Now:yyyyMMdd_HHmm}.zip",
-            FileContent = memoryStream.ToArray()
-        };
-    }
-    
-    private static byte[] CreateZipBytes(IEnumerable<FileInfo> files)
-    {
-        using var ms = new MemoryStream();
-        using (var archive = new ZipArchive(ms, ZipArchiveMode.Create, leaveOpen: true))
-        {
-            foreach (var file in files)
-            {
-                if (!file.Exists)
-                    continue;
-
-                // Nome dentro lo zip (evita path e collisioni minime)
-                var entryName = file.Name;
-
-                var entry = archive.CreateEntry(entryName, CompressionLevel.Optimal);
-
-                using var entryStream = entry.Open();
-                using var fileStream = file.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-
-                fileStream.CopyTo(entryStream);
-            }
-        }
-
-        return ms.ToArray();
-    }
-    
-    private static byte[] CreateZipBytes(string rootDir, IEnumerable<FileInfo> files)
-    {
-        using var ms = new MemoryStream();
-
-        using (var archive = new ZipArchive(ms, ZipArchiveMode.Create, leaveOpen: true))
-        {
-            foreach (var file in files)
-            {
-                if (!file.Exists)
-                    continue;
-
-                // Path relativo rispetto a rootDir -> mantiene le directory nello zip
-                var relativePath = Path.GetRelativePath(rootDir, file.FullName);
-
-                // Zip usa "/" come separatore: normalizziamo per compatibilità
-                var entryName = relativePath.Replace('\\', '/');
-
-                var entry = archive.CreateEntry(entryName, CompressionLevel.Optimal);
-
-                using var entryStream = entry.Open();
-                using var fileStream = file.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-
-                fileStream.CopyTo(entryStream);
-            }
-        }
-
-        return ms.ToArray();
+        // Ordine per percorso: le foto della stessa ispezione finiscono nella stessa parte.
+        // Il percorso relativo mantiene le cartelle dentro lo zip (separatore "/" per compatibilità).
+        return root
+            .EnumerateFiles("*", SearchOption.AllDirectories)
+            .OrderBy(f => f.FullName, StringComparer.Ordinal)
+            .Select(f => new LogExport.ZipItem(f,
+                Path.GetRelativePath(root.FullName, f.FullName).Replace('\\', '/')))
+            .ToList();
     }
 }

SteUp.Maui/Core/Services/LogExport.cs

@@ -0,0 +1,171 @@
+using System.IO.Compression;
+using Microsoft.Extensions.Logging;
+using SteUp.Shared.Core.Dto;
+using SteUp.Shared.Core.Interface.System;
+
+namespace SteUp.Maui.Core.Services;
+
+/// <summary>
+/// Divide l'invio dei log in parti sotto <see cref="MaxPartBytes"/>: la prima porta log, database
+/// e le prime immagini, le successive solo immagini. Gli zip vengono scritti su disco (mai in RAM)
+/// una parte alla volta, così lo spazio occupato resta quello di una sola parte.
+/// </summary>
+internal sealed class LogExport : ILogExport
+{
+    // Ben sotto il max-file-size dei servizi (100 MB) e i limiti tipici dei server di posta.
+    // Una parte piccola regge anche l'upload da rete mobile entro il timeout HTTP del client.
+    internal const long MaxPartBytes = 40L * 1024 * 1024;
+
+    private const int BufferSize = 81920;
+
+    internal readonly record struct ZipItem(FileInfo File, string EntryName);
+
+    private readonly string _workDir;
+    private readonly List<ZipItem> _logFiles;
+    private readonly List<ZipItem> _dbFiles;
+    private readonly List<List<ZipItem>> _imageParts;
+    private readonly ILogger _logger;
+    private readonly List<string> _currentPartFiles = [];
+
+    public int PartCount => _imageParts.Count;
+
+    internal LogExport(string workDir, List<ZipItem> logFiles, List<ZipItem> dbFiles, List<ZipItem> images,
+        ILogger logger)
+    {
+        _workDir = workDir;
+        _logFiles = logFiles;
+        _dbFiles = dbFiles;
+        _logger = logger;
+        _imageParts = SplitImages(images, logFiles.Concat(dbFiles).Sum(x => x.File.Length));
+    }
+
+    /// <summary>
+    /// Riempie le parti in ordine (le foto di un'ispezione restano vicine). La prima parte parte
+    /// già occupata da log e database: uso le dimensioni non compresse, una stima per eccesso.
+    /// Un file più grande di una parte finisce da solo in una parte sua.
+    /// </summary>
+    private static List<List<ZipItem>> SplitImages(List<ZipItem> images, long firstPartReserved)
+    {
+        var parts = new List<List<ZipItem>> { new() };
+        var currentSize = firstPartReserved;
+
+        foreach (var image in images)
+        {
+            var length = image.File.Length;
+            if (currentSize > 0 && currentSize + length > MaxPartBytes)
+            {
+                parts.Add([]);
+                currentSize = 0;
+            }
+
+            parts[^1].Add(image);
+            currentSize += length;
+        }
+
+        return parts;
+    }
+
+    public Task<List<SendEmailDto.AttachmentsDto>> BuildPartAsync(int index, CancellationToken ct = default)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(index);
+        ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, PartCount);
+
+        // Task.Run: la compressione non deve bloccare il thread della UI.
+        return Task.Run(() =>
+        {
+            DeleteCurrentPartFiles();
+
+            var attachments = new List<SendEmailDto.AttachmentsDto>();
+            var date = DateTime.Today.ToString("yyyyMMdd");
+
+            if (index == 0)
+            {
+                if (_logFiles.Count > 0)
+                    attachments.Add(WriteZip($"logs_{date}.zip", _logFiles, CompressionLevel.Optimal, ct));
+
+                if (_dbFiles.Count > 0)
+                    attachments.Add(WriteZip($"database_{DateTime.Now:yyyyMMdd_HHmm}.zip", _dbFiles,
+                        CompressionLevel.Optimal, ct));
+            }
+
+            var images = _imageParts[index];
+            if (images.Count > 0)
+            {
+                var suffix = PartCount > 1 ? $"_parte{index + 1}di{PartCount}" : string.Empty;
+
+                // JPEG già compressi: ricomprimerli costa CPU e non riduce quasi niente.
+                attachments.Add(WriteZip($"immagini_allegate_{date}{suffix}.zip", images,
+                    CompressionLevel.NoCompression, ct));
+            }
+
+            return attachments;
+        }, ct);
+    }
+
+    private SendEmailDto.AttachmentsDto WriteZip(string fileName, List<ZipItem> items, CompressionLevel level,
+        CancellationToken ct)
+    {
+        var path = Path.Combine(_workDir, fileName);
+        _currentPartFiles.Add(path);
+
+        using (var zipStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None, BufferSize))
+        using (var archive = new ZipArchive(zipStream, ZipArchiveMode.Create))
+        {
+            foreach (var item in items)
+            {
+                ct.ThrowIfCancellationRequested();
+
+                try
+                {
+                    // FileShare.ReadWrite: log e database possono essere ancora aperti in scrittura.
+                    using var source = item.File.Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+
+                    var entry = archive.CreateEntry(item.EntryName, level);
+                    entry.LastWriteTime = item.File.LastWriteTime;
+
+                    using var entryStream = entry.Open();
+                    source.CopyTo(entryStream, BufferSize);
+                }
+                catch (Exception e) when (e is IOException or UnauthorizedAccessException)
+                {
+                    // Un file sparito o bloccato non deve far saltare tutto l'invio.
+                    _logger.LogWarning(e, "Export log: file {File} saltato", item.File.FullName);
+                }
+            }
+        }
+
+        return new SendEmailDto.AttachmentsDto { FileName = fileName, FilePath = path };
+    }
+
+    private void DeleteCurrentPartFiles()
+    {
+        foreach (var path in _currentPartFiles)
+        {
+            try
+            {
+                File.Delete(path);
+            }
+            catch (Exception e)
+            {
+                _logger.LogWarning(e, "Export log: impossibile eliminare {File}", path);
+            }
+        }
+
+        _currentPartFiles.Clear();
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        try
+        {
+            if (Directory.Exists(_workDir))
+                Directory.Delete(_workDir, true);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Export log: impossibile eliminare {Dir}", _workDir);
+        }
+
+        return ValueTask.CompletedTask;
+    }
+}

SteUp.Maui/Platforms/Android/AndroidManifest.xml

@@ -25,4 +25,11 @@
     <uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
     <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
     <uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
+
+    <!-- Android 11+: rende visibile l'app fotocamera di sistema a MediaPicker -->
+    <queries>
+        <intent>
+            <action android:name="android.media.action.IMAGE_CAPTURE" />
+        </intent>
+    </queries>
 </manifest>

SteUp.Maui/SteUp.Maui.csproj

@@ -30,8 +30,8 @@
         <ApplicationId>it.integry.SteUp</ApplicationId>
 
         <!-- Versions -->
-        <ApplicationDisplayVersion>1.2.0</ApplicationDisplayVersion>
-        <ApplicationVersion>6</ApplicationVersion>
+        <ApplicationDisplayVersion>1.2.3</ApplicationDisplayVersion>
+        <ApplicationVersion>9</ApplicationVersion>
 
         <SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">15.0</SupportedOSPlatformVersion>
         <!--		<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'maccatalyst'">-->

SteUp.Shared/Components/Pages/IspezionePage.razor

@@ -157,6 +157,7 @@
             @foreach (var group in SchedeGrouped)
             {
                 var reparto = group.Key;
+                var senzaReparto = ReferenceEquals(reparto, SenzaReparto);
                 var chiuso = IsCollapsed(reparto);
                 var daInviare = group.Value.CountDaInviare();
 
@@ -172,7 +173,9 @@
                         </button>
 
                         <div class="reparto__actions">
-                            @if (!IsCompleted)
+                            @* Il gruppo "Senza reparto" raccoglie solo bozze da
+                               sistemare: non ha un "+" ne' un invio suo. *@
+                            @if (!IsCompleted && !senzaReparto)
                             {
                                 @* Da qui la scheda nasce gia' con il suo reparto: e'
                                    l'unica differenza con il "+" della barra. *@
@@ -326,13 +329,15 @@
     // schermata, non del documento.
     private readonly HashSet<string> _collapsed = new(StringComparer.OrdinalIgnoreCase);
 
-    private bool IsCollapsed(JtbFasiDto reparto) =>
-        reparto.CodJfas is not null && _collapsed.Contains(reparto.CodJfas);
+    // Il gruppo "Senza reparto" non ha codice: la chiave vuota e' la sua.
+    private static string CollapseKey(JtbFasiDto reparto) => reparto.CodJfas ?? string.Empty;
+
+    private bool IsCollapsed(JtbFasiDto reparto) => _collapsed.Contains(CollapseKey(reparto));
 
     private void Toggle(JtbFasiDto reparto)
     {
-        if (reparto.CodJfas is null) return;
-        if (!_collapsed.Remove(reparto.CodJfas)) _collapsed.Add(reparto.CodJfas);
+        var key = CollapseKey(reparto);
+        if (!_collapsed.Remove(key)) _collapsed.Add(key);
     }
 
     private static string Conteggi(List<Scheda> schede)
@@ -542,15 +547,22 @@
             StateHasChanged();
         });
 
+    // Una bozza si puo' salvare anche senza reparto: senza questo gruppo
+    // sparirebbe dall'elenco pur restando sul dispositivo e contata fra le bozze.
+    private static readonly JtbFasiDto SenzaReparto = new() { Descrizione = "Senza reparto" };
+
     private void GroupSchede()
     {
-        SchedeGrouped = SchedeList
-            .Where(s => s.Reparto != null)
-            .GroupBy(s => s.CodJfas)
-            .ToDictionary(
-                g => g.First().Reparto!,
-                g => g.ToList()
-            );
+        var grouped = new Dictionary<JtbFasiDto, List<Scheda>>();
+
+        // In testa: sono schede a meta' che chiedono di essere completate.
+        var senzaReparto = SchedeList.FindAll(s => s.Reparto == null);
+        if (senzaReparto.Count > 0) grouped[SenzaReparto] = senzaReparto;
+
+        foreach (var g in SchedeList.Where(s => s.Reparto != null).GroupBy(s => s.CodJfas))
+            grouped[g.First().Reparto!] = g.ToList();
+
+        SchedeGrouped = grouped;
     }
 
     private void OnSchedaModified(Scheda obj)

SteUp.Shared/Components/Pages/UserPage.razor

@@ -1,5 +1,6 @@
 @page "/user"
 @attribute [Authorize]
+@using Microsoft.Extensions.Logging
 @using SteUp.Shared.Components.Layout
 @using SteUp.Shared.Components.Layout.Overlay
 @using SteUp.Shared.Components.SingleElements
@@ -14,6 +15,7 @@
 @inject IGenericSystemService GenericSystemService
 @inject IFileManager FileManager
 @inject IIntegryApiService IntegryApiService
+@inject ILogger<UserPage> Logger
 
 <HeaderLayout Title="Profilo"/>
 
@@ -87,6 +89,9 @@
 <ConfirmMessageBox @ref="_logoutBox" Title="Uscire dall'account?" NoText="Annulla"
                    YesText="Esci" YesColor="Color.Error"
                    Message="Uscendo servirà di nuovo la connessione per rientrare. Le ispezioni salvate sul dispositivo restano al loro posto."/>
+<ConfirmMessageBox @ref="_imagesBox" Title="Inviare anche le foto?" NoText="Annulla"
+                   YesText="Solo i log" AltText="Includi le foto"
+                   Message="@_imagesBoxMessage"/>
 
 @code {
     private bool IsLoggedIn { get; set; }
@@ -95,6 +100,8 @@
     private string? CodHash { get; set; } = "";
 
     private ConfirmMessageBox _logoutBox = null!;
+    private ConfirmMessageBox _imagesBox = null!;
+    private string _imagesBoxMessage = string.Empty;
 
     private Core.Helpers.StatusBadgeHelper.BadgeSpec ConnessioneBadge => NetworkService.ConnectionAvailable
         ? new Core.Helpers.StatusBadgeHelper.BadgeSpec("success", "ri-cloud-line", "Online")
@@ -109,33 +116,69 @@
 
     private async Task ExportLog()
     {
-        _progressMessage = "Invio dei log…";
+        if (VisibleOverlay) return;
+
+        if (!NetworkService.ConnectionAvailable)
+        {
+            Snackbar.Add("Sei offline: per inviare i log serve la connessione.", Severity.Warning);
+            return;
+        }
+
+        var includeImages = await AskIncludeImages();
+        if (includeImages is null) return;
+
+        _progressMessage = "Preparazione dei log…";
         VisibleOverlay = true;
         StateHasChanged();
 
+        var partCount = 0;
+        var sentParts = 0;
+
         try
         {
-            var profiloAzienda = LocalStorage.GetString("codHash");
+            // Un'email per parte: ogni parte resta sotto i limiti di upload dei servizi.
+            await using var export = await FileManager.PrepareLogExportAsync(includeImages.Value);
+            partCount = export.PartCount;
 
-            var email = new SendEmailDto
+            var profiloAzienda = LocalStorage.GetString("codHash");
+            var subject = $"SteUP - Log del {DateTime.Today:d} di {UserSession.User.Username}";
+            var body = $"Username: <b>{UserSession.User.Username}</b><br/>" +
+                       $"Profilo azienda: <b>{profiloAzienda}</b><br/>" +
+                       $"ProfileDb: <b>{UserSession.ProfileDb}</b><br/>" +
+                       $"Versione app: <b>{GenericSystemService.GetCurrentAppVersion()}</b>";
+
+            for (var i = 0; i < partCount; i++)
+            {
+                var multiPart = partCount > 1;
+
+                _progressMessage = multiPart ? $"Invio dei log… parte {i + 1} di {partCount}" : "Invio dei log…";
+                StateHasChanged();
+
+                var attachments = await export.BuildPartAsync(i);
+
+                await IntegryApiService.SendEmail(new SendEmailDto
                 {
                     FromName = "Integry Log",
                     To = "developer@integry.it",
-                Subject = $"SteUP - Log del {DateTime.Today:d} di {UserSession.User.Username}",
+                    Subject = multiPart ? $"{subject} (parte {i + 1}/{partCount})" : subject,
                     IsHtml = true,
-                MsgText = $"Username: <b>{UserSession.User.Username}</b><br/>" +
-                          $"Profilo azienda: <b>{profiloAzienda}</b><br/>" +
-                          $"ProfileDb: <b>{UserSession.ProfileDb}</b><br/>" +
-                          $"Versione app: <b>{GenericSystemService.GetCurrentAppVersion()}</b>",
-                Attachments = FileManager.GetFileForExport()
-            };
+                    MsgText = multiPart ? $"{body}<br/>Parte: <b>{i + 1} di {partCount}</b>" : body,
+                    Attachments = attachments
+                });
 
-            await IntegryApiService.SendEmail(email);
-            Snackbar.Add("Log inviati allo sviluppo", Severity.Success);
+                sentParts++;
             }
-        catch
+
+            Snackbar.Add(partCount > 1 ? $"Log inviati allo sviluppo in {partCount} parti" : "Log inviati allo sviluppo",
+                Severity.Success);
+        }
+        catch (Exception e)
         {
-            Snackbar.Add("Invio dei log non riuscito. Controlla la connessione e riprova.", Severity.Error);
+            Logger.LogError(e, "Invio dei log interrotto dopo {Sent} parti su {Total}", sentParts, partCount);
+            Snackbar.Add(sentParts > 0
+                    ? $"Invio interrotto: inviate {sentParts} parti su {partCount}. Controlla la connessione e riprova."
+                    : "Invio dei log non riuscito. Controlla la connessione e riprova.",
+                Severity.Error);
         }
         finally
         {
@@ -145,6 +188,49 @@
         }
     }
 
+    /// <summary>
+    /// Chiede se allegare le foto, indicando quanto pesano. Null = invio annullato.
+    /// Se sul dispositivo non ci sono foto non chiede niente.
+    /// </summary>
+    private async Task<bool?> AskIncludeImages()
+    {
+        long imagesSize;
+
+        _progressMessage = "Controllo delle foto…";
+        VisibleOverlay = true;
+        StateHasChanged();
+
+        try
+        {
+            imagesSize = await FileManager.GetLogExportImagesSizeAsync();
+        }
+        catch (Exception e)
+        {
+            // Senza sapere quanto pesano, meglio un invio leggero che uno che rischia di fallire.
+            Logger.LogWarning(e, "Impossibile calcolare la dimensione delle foto da inviare");
+            imagesSize = 0;
+        }
+        finally
+        {
+            VisibleOverlay = false;
+            _progressMessage = null;
+            StateHasChanged();
+        }
+
+        if (imagesSize == 0) return false;
+
+        var sizeText = imagesSize < 1024 * 1024
+            ? "meno di 1 MB"
+            : $"circa {imagesSize / (1024d * 1024):N0} MB";
+        _imagesBoxMessage = $"Le foto delle ispezioni occupano {sizeText}. Servono solo se il problema " +
+                            "riguarda le foto: senza, l'invio è molto più veloce.";
+        StateHasChanged();
+
+        // "Solo i log" è la scelta consigliata (pulsante pieno, true); "Includi le foto" -> false.
+        var result = await _imagesBox.ShowAsync();
+        return result is null ? null : result == false;
+    }
+
     private async Task UpdateDb()
     {
         _progressMessage = "Sincronizzazione…";

SteUp.Shared/Components/SingleElements/Card/SchedaCard.razor

@@ -16,7 +16,7 @@
 <div class="list-card" aria-label="@SemanticLabel">
     <div class="list-card__head">
         <div class="list-card__ident">
-            <div class="t-ident">@Scheda.DescrizioneReparto</div>
+            <div class="t-ident">@(Scheda.DescrizioneReparto ?? "Senza reparto")</div>
             <h3 class="list-card__title">@Titolo</h3>
         </div>
     </div>
@@ -125,7 +125,7 @@
     };
 
     private string SemanticLabel =>
-        $"Scheda {Titolo}, reparto {Scheda.DescrizioneReparto}, {SyncState.ToBadge().Label}, {ArticoliLabel}, {FotoLabel}";
+        $"Scheda {Titolo}, reparto {Scheda.DescrizioneReparto ?? "non indicato"},{SyncState.ToBadge().Label}, {ArticoliLabel}, {FotoLabel}";
 
     private async Task SetBusy(bool value)
     {

SteUp.Shared/Components/SingleElements/MessageBox/ConfirmMessageBox.razor

@@ -2,8 +2,9 @@
    che conseguenze ha: davanti a un'azione irreversibile la domanda deve
    essere leggibile prima del testo, non dedotta da esso.
 
-   YesText -> true, NoText -> false, chiusura senza scelta -> null. *@
-<MudMessageBox @ref="_confirmDelete" Title="@Title" CancelText="@NoText">
+   YesText -> true, NoText o chiusura senza scelta -> null.
+   AltText (opzionale) aggiunge una seconda scelta valida -> false. *@
+<MudMessageBox @ref="_confirmDelete" Title="@Title" CancelText="@NoText" NoText="@AltText">
     <MessageContent>
         @Message
     </MessageContent>
@@ -20,6 +21,7 @@
     [Parameter] public string Message { get; set; } = string.Empty;
     [Parameter] public string YesText { get; set; } = string.Empty;
     [Parameter] public string NoText { get; set; } = "Annulla";
+    [Parameter] public string? AltText { get; set; }
     [Parameter] public Color YesColor { get; set; } = Color.Primary;
 
     private MudMessageBox? _confirmDelete;

SteUp.Shared/Components/SingleElements/Modal/ModalAddAttached.razor

@@ -40,7 +40,32 @@
 
     private async Task OnCamera()
     {
-        var selectImageFromCamera = await AttachedService.SelectImageFromCamera();
+        if (!await AttachedService.RequestCameraPermissions())
+        {
+            Snackbar.Clear();
+            Snackbar.Add("Per scattare le foto serve il permesso della fotocamera", Severity.Warning, config =>
+            {
+                config.Action = "Impostazioni";
+                config.OnClick = _ =>
+                {
+                    AttachedService.OpenAppSettings();
+                    return Task.CompletedTask;
+                };
+            });
+            return;
+        }
+
+        AttachedDto? selectImageFromCamera;
+        try
+        {
+            selectImageFromCamera = await AttachedService.SelectImageFromCamera();
+        }
+        catch (Exception)
+        {
+            Snackbar.Clear();
+            Snackbar.Add("Non è stato possibile scattare la foto, riprova", Severity.Error);
+            return;
+        }
 
         if (selectImageFromCamera != null)
         {

SteUp.Shared/Components/SingleElements/Modal/ModalFormScheda.razor

@@ -754,12 +754,60 @@
 
     #region File
 
+    // Dopo un rifiuto definitivo Android non ripropone la richiesta: il
+    // permesso si riattiva solo dalle impostazioni, quindi le apriamo noi.
+    private void ShowCameraPermissionDenied()
+    {
+        Snackbar.Clear();
+        Snackbar.Add("Per scattare le foto serve il permesso della fotocamera", Severity.Warning, config =>
+        {
+            config.Action = "Impostazioni";
+            config.OnClick = _ =>
+            {
+                AttachedService.OpenAppSettings();
+                return Task.CompletedTask;
+            };
+        });
+    }
+
     private async Task OpenAddAttached()
     {
-        var selectImageFromCamera = await AttachedService.SelectImageFromCamera();
-        if (selectImageFromCamera == null) return;
+        List<AttachedDto>? attachedList;
 
-        var attachedList = new List<AttachedDto> { selectImageFromCamera };
+        if (AttachedService.IsCameraAvailable)
+        {
+            if (!await AttachedService.RequestCameraPermissions())
+            {
+                ShowCameraPermissionDenied();
+                return;
+            }
+
+            AttachedDto? selectImageFromCamera;
+            try
+            {
+                selectImageFromCamera = await AttachedService.SelectImageFromCamera();
+            }
+            catch (Exception)
+            {
+                // Gia' registrato e inviato a Sentry dal servizio
+                Snackbar.Clear();
+                Snackbar.Add("Non è stato possibile scattare la foto, riprova", Severity.Error);
+                return;
+            }
+
+            if (selectImageFromCamera == null) return;
+            attachedList = [selectImageFromCamera];
+        }
+        else
+        {
+            // Senza fotocamera "Aggiungi una foto" non avrebbe altra strada:
+            // si passa alla galleria invece di lasciare il rilevatore fermo.
+            Snackbar.Clear();
+            Snackbar.Add("Fotocamera non disponibile: scegli la foto dalla galleria", Severity.Warning);
+
+            attachedList = await AttachedService.SelectImageFromGallery();
+            if (attachedList is null || attachedList.Count == 0) return;
+        }
 
         OnLoading = true;
         await InvokeAsync(StateHasChanged);

SteUp.Shared/Core/Dto/SendEmailDto.cs

@@ -22,12 +22,15 @@ public class SendEmailDto
     [JsonPropertyName("html")]
     public bool IsHtml { get; set; }
 
-    [JsonPropertyName("attachments")]
+    // Gli allegati viaggiano come parti multipart "allegati", non dentro il JSON della richiesta.
+    [JsonIgnore]
     public List<AttachmentsDto>? Attachments { get; set; }
 
     public class AttachmentsDto
     {
         public string FileName { get; set; } = string.Empty;
-        public byte[] FileContent { get; set; } = [];
+
+        // Il file resta su disco e viene letto in streaming durante l'upload.
+        public string FilePath { get; set; } = string.Empty;
     }
 }

SteUp.Shared/Core/Helpers/FileHttpContent.cs

@@ -0,0 +1,39 @@
+using System.Net;
+using System.Net.Http.Headers;
+
+namespace SteUp.Shared.Core.Helpers;
+
+/// <summary>
+/// Contenuto HTTP letto dal file durante l'invio, senza caricarlo in RAM. Il file viene riaperto
+/// a ogni serializzazione, così regge anche un eventuale nuovo tentativo del client
+/// (es. dopo il refresh del token).
+/// </summary>
+public sealed class FileHttpContent : HttpContent
+{
+    private const int BufferSize = 81920;
+
+    private readonly string _path;
+
+    public FileHttpContent(string path, string mediaType)
+    {
+        _path = path;
+        Headers.ContentType = new MediaTypeHeaderValue(mediaType);
+    }
+
+    protected override Task SerializeToStreamAsync(Stream stream, TransportContext? context) =>
+        SerializeToStreamAsync(stream, context, CancellationToken.None);
+
+    protected override async Task SerializeToStreamAsync(Stream stream, TransportContext? context,
+        CancellationToken cancellationToken)
+    {
+        await using var file = new FileStream(_path, FileMode.Open, FileAccess.Read, FileShare.Read,
+            BufferSize, useAsync: true);
+        await file.CopyToAsync(stream, BufferSize, cancellationToken);
+    }
+
+    protected override bool TryComputeLength(out long length)
+    {
+        length = new FileInfo(_path).Length;
+        return true;
+    }
+}

SteUp.Shared/Core/Interface/System/IAttachedService.cs

@@ -4,6 +4,14 @@ namespace SteUp.Shared.Core.Interface.System;
 
 public interface IAttachedService
 {
+    bool IsCameraAvailable { get; }
+
+    /// <summary>Chiede i permessi per scattare; false se negati.</summary>
+    Task<bool> RequestCameraPermissions();
+
+    void OpenAppSettings();
+
+    /// <summary>Null se l'utente annulla; lancia se lo scatto fallisce.</summary>
     Task<AttachedDto?> SelectImageFromCamera();
     Task<List<AttachedDto>?> SelectImageFromGallery();
 }

SteUp.Shared/Core/Interface/System/IFileManager.cs

@@ -26,5 +26,6 @@ public interface IFileManager
     Task<(string originalUrl, string thumbUrl)> SaveAndCreateThumbAsync(byte[] bytes, string fileName,
         CancellationToken ct = default);
 
-    List<SendEmailDto.AttachmentsDto> GetFileForExport();
+    Task<long> GetLogExportImagesSizeAsync(CancellationToken ct = default);
+    Task<ILogExport> PrepareLogExportAsync(bool includeImages, CancellationToken ct = default);
 }

SteUp.Shared/Core/Interface/System/ILogExport.cs

@@ -0,0 +1,15 @@
+using SteUp.Shared.Core.Dto;
+
+namespace SteUp.Shared.Core.Interface.System;
+
+/// <summary>
+/// Invio dei log diviso in parti: ogni parte diventa un'email separata, sotto i limiti di upload
+/// dei servizi. Gli zip di una parte vengono creati solo quando la si chiede e cancellati alla
+/// parte successiva; il dispose elimina tutto quello che resta su disco.
+/// </summary>
+public interface ILogExport : IAsyncDisposable
+{
+    int PartCount { get; }
+
+    Task<List<SendEmailDto.AttachmentsDto>> BuildPartAsync(int index, CancellationToken ct = default);
+}

SteUp.Shared/Core/Services/IntegryApiService.cs

@@ -1,9 +1,9 @@
-using System.Net.Http.Headers;
-using System.Text;
+using System.Text;
 using System.Text.Json;
 using IntegryApiClient.Core.Domain.RestClient.Contacts;
 using Microsoft.Extensions.Logging;
 using SteUp.Shared.Core.Dto;
+using SteUp.Shared.Core.Helpers;
 using SteUp.Shared.Core.Interface.IntegryApi;
 
 namespace SteUp.Shared.Core.Services;
@@ -37,21 +37,18 @@ public class IntegryApiService(
 
     public async Task SendEmail(SendEmailDto sendEmail)
     {
-        var content = new MultipartFormDataContent();
+        using var content = new MultipartFormDataContent();
 
         try
         {
-            if (sendEmail.Attachments != null)
+            foreach (var a in sendEmail.Attachments ?? [])
             {
-                foreach (var a in sendEmail.Attachments)
-                {
-                    var fileContent = new ByteArrayContent(a.FileContent);
-                    fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
-                    content.Add(fileContent, "allegati", a.FileName);
-                }
+                var mediaType = a.FileName.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)
+                    ? "application/zip"
+                    : "application/octet-stream";
+                content.Add(new FileHttpContent(a.FilePath, mediaType), "allegati", a.FileName);
             }
 
-            sendEmail.Attachments = null;
             content.Add(
                 new StringContent(
                     JsonSerializer.Serialize(sendEmail),
@@ -69,9 +66,5 @@ public class IntegryApiService(
             logger.LogError(e, e.Message);
             throw;
         }
-        finally
-        {
-            content.Dispose();
-        }
     }
 }