feat: add task persistence

Author: mateof

TelegramDownloader/Data/FileService.cs

@@ -232,18 +232,20 @@ public class FileService : IFileService
         protected ILogger<IFileService> _logger { get; set; }
         protected TransactionInfoService _tis { get; set; }
         protected ToastService _toastService { get; set;  }
+        protected ITaskPersistenceService _persistence { get; set; }
         private static Mutex refreshMutex = new Mutex();
 
-        const int MaxSize = 1024 * 1024 * 1000; // 1GB 
+        const int MaxSize = 1024 * 1024 * 1000; // 1GB
 
 
-        public FileService(ITelegramService ts, IDbService db, ILogger<IFileService> logger, TransactionInfoService tis, ToastService toastService)
+        public FileService(ITelegramService ts, IDbService db, ILogger<IFileService> logger, TransactionInfoService tis, ToastService toastService, ITaskPersistenceService persistence)
         {
             _ts = ts;
             _db = db;
             _tis = tis;
             _toastService = toastService;
             _logger = logger;
+            _persistence = persistence;
             createTempFolder();
         }
 
@@ -1227,6 +1229,18 @@ public async Task AddUploadFileFromServer(string dbName, string currentPath, Lis
             }
             idt.callbacks = new Callbacks();
             idt.callbacks.callback = async () => await UploadFileFromServer(dbName, currentPath, files, idt);
+
+            // Persist the batch task
+            try
+            {
+                idt.channelId = dbName;
+                await _persistence.PersistBatchTask(idt);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to persist batch task - continuing without persistence");
+            }
+
             _tis.addToInfoDownloadTaskList(idt);
             _tis.CheckPendingUploadInfoTasks();
         }

TelegramDownloader/Data/FileServiceV2.cs

@@ -27,10 +27,10 @@ public FileServiceV2(
         IDbService db,
         ILogger<IFileService> logger,
         TransactionInfoService tis,
-        ToastService toastService
-    ) : base(ts, db, logger, tis, toastService)
+        ToastService toastService,
+        ITaskPersistenceService persistence
+    ) : base(ts, db, logger, tis, toastService, persistence)
         {
-           
         }
 
         public override async Task downloadFile(string dbName, List<FileManagerDirectoryContent> files, string targetPath, string? collectionId = null, string? channelId = null)
@@ -133,16 +133,44 @@ public async Task downloadFromTelegramV2(string dbName, int messageId, string de
             {
                 model.channelName = "Public or Shared";
             }
+
+            // Setup persistence
+            model.OnProgressPersist = async (transmitted, progress, state) =>
+            {
+                try
+                {
+                    await _persistence.UpdateProgress(model._internalId, transmitted, progress, state);
+                }
+                catch { }
+            };
+
+            // Persist download task
+            try
+            {
+                await _persistence.PersistDownload(model, dbName, messageId, file);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to persist download task - continuing without persistence");
+            }
+
             var tcs = new TaskCompletionSource<bool>();
 
             EventHandler handler = null;
-            handler = (sender, args) =>
+            handler = async (sender, args) =>
             {
                 if (model.state == StateTask.Completed)
                 {
                     model.EventStatechanged -= handler;
+                    await _persistence.MarkCompleted(model._internalId);
                     tcs.SetResult(true);
                 }
+                else if (model.state == StateTask.Error || model.state == StateTask.Canceled)
+                {
+                    model.EventStatechanged -= handler;
+                    await _persistence.MarkError(model._internalId, model.state.ToString());
+                    tcs.TrySetResult(false);
+                }
             };
 
             model.EventStatechanged += handler;
@@ -173,6 +201,46 @@ public async Task DownloadFileNowV2(string dbName, int messageId, string destPat
 
         }
 
+        /// <summary>
+        /// Download file with support for resuming from a specific byte offset
+        /// </summary>
+        public async Task DownloadFileNowV2WithOffset(string dbName, int messageId, string destPath, DownloadModel model, long resumeOffset = 0)
+        {
+            TL.Message m = await _ts.getMessageFile(dbName, messageId);
+            ChatMessages cm = new ChatMessages();
+            cm.message = m;
+            model.startDate = DateTime.Now;
+
+            cm.user = null;
+            cm.isDocument = false;
+            if (m.media is MessageMediaDocument { document: Document document })
+            {
+                cm.isDocument = true;
+                model._size = document.size;
+                model._sizeString = Services.HelperService.SizeSuffix(document.size);
+            }
+
+            // Determine file mode based on resume offset
+            FileMode fileMode = resumeOffset > 0 ? FileMode.Append : FileMode.Create;
+
+            _logger.LogInformation("DownloadFileNowV2WithOffset - File: {Name}, Offset: {Offset}, Mode: {Mode}",
+                model.name, resumeOffset, fileMode);
+
+            using (FileStream fs = new FileStream(destPath, fileMode, FileAccess.Write, FileShare.ReadWrite))
+            {
+                // If resuming, validate file size
+                if (resumeOffset > 0 && fs.Length < resumeOffset)
+                {
+                    // File is smaller than expected offset - restart from current file size
+                    resumeOffset = fs.Length;
+                    model._transmitted = resumeOffset;
+                    model._transmittedString = Services.HelperService.SizeSuffix(resumeOffset);
+                }
+
+                await _ts.DownloadFileAndReturnWithOffset(cm, ms: fs, model: model, offset: resumeOffset);
+            }
+        }
+
         public override async Task<int> PreloadFilesToTemp(string channelId, List<FileManagerDirectoryContent> items)
         {
             _logger.LogInformation("Starting preload files to temp V2 - ChannelId: {ChannelId}, ItemsCount: {Count}", channelId, items.Count);

TelegramDownloader/Data/ITelegramService.cs

@@ -19,6 +19,7 @@ public interface ITelegramService
         Task<string> DownloadFile(ChatMessages message, string fileName = null, string folder = null, DownloadModel model = null, bool shouldAddToList = false);
         Task<Byte[]> DownloadFileStream(Message message, long offset, int limit);
         Task<Stream> DownloadFileAndReturn(ChatMessages message, Stream ms = null, string fileName = null, string folder = null, DownloadModel model = null);
+        Task<Stream> DownloadFileAndReturnWithOffset(ChatMessages message, Stream ms = null, string fileName = null, string folder = null, DownloadModel model = null, long offset = 0);
         Task<List<ChatViewBase>> GetFouriteChannels(bool mustRefresh = true);
         Task AddFavouriteChannel(long id);
         Task RemoveFavouriteChannel(long id);

TelegramDownloader/Data/TelegramService.cs

@@ -26,18 +26,20 @@ public class TelegramService : ITelegramService
         private const int FILESPLITSIZE = 524288; // 512 * 1024;
         private TransactionInfoService _tis { get; set; }
         private IDbService _db { get; set; }
+        private ITaskPersistenceService _persistence { get; set; }
         private static WTelegram.Client client = null;
         private static Messages_Chats chats = null;
         private static List<ChatViewBase> favouriteChannels = new List<ChatViewBase>();
         private static Mutex mut = new Mutex();
         private ILogger<IFileService> _logger { get; set; }
 
 
-        public TelegramService(TransactionInfoService tis, IDbService db, ILogger<IFileService> logger)
+        public TelegramService(TransactionInfoService tis, IDbService db, ILogger<IFileService> logger, ITaskPersistenceService persistence)
         {
             _tis = tis;
             _db = db;
             _logger = logger;
+            _persistence = persistence;
             // createDownloadFolder();
             mut.WaitOne();
             if (client == null)
@@ -341,16 +343,39 @@ public async Task<Message> uploadFile(string chatId, Stream file, string fileNam
             um.startDate = DateTime.Now;
             um._transmitted = 0;
             _tis.addToUploadList(um);
+
+            // Persist the upload task
+            try
+            {
+                um.OnProgressPersist = async (transmitted, progress, state) =>
+                {
+                    await _persistence.UpdateProgress(um._internalId, transmitted, progress, state);
+                };
+                await _persistence.PersistUpload(um, chatId, um.path);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to persist upload task - continuing without persistence");
+            }
+
             try
             {
                 var inputFile = await client.UploadFileAsync(file, fileName, um.ProgressCallback);
                 var result = await client.SendMediaAsync(peer, caption ?? fileName, inputFile, mimeType);
                 _logger.LogInformation("File upload completed - FileName: {FileName}, MessageId: {MessageId}", fileName, result.id);
+
+                // Mark task as completed
+                await _persistence.MarkCompleted(um._internalId);
+
                 return result;
             }
             catch (Exception ex)
             {
                 _logger.LogError(ex, "File upload failed - FileName: {FileName}, ChatId: {ChatId}", fileName, chatId);
+
+                // Mark task as error
+                await _persistence.MarkError(um._internalId, ex.Message);
+
                 throw;
             }
         }
@@ -803,6 +828,129 @@ public async Task<Stream> DownloadFileAndReturn(ChatMessages message, Stream ms
             return null;
         }
 
+        public async Task<Stream> DownloadFileAndReturnWithOffset(ChatMessages message, Stream ms = null, string fileName = null, string folder = null, DownloadModel model = null, long offset = 0)
+        {
+            if (model == null)
+            {
+                model = new DownloadModel();
+                model.tis = _tis;
+            }
+
+            model.m = message;
+            model.channel = message.user;
+
+            if (message.message.media is MessageMediaDocument { document: TL.Document document })
+            {
+                model._size = document.size;
+                model._transmitted = offset;
+                var filename = fileName ?? document.Filename;
+                filename ??= $"{document.id}.{document.mime_type[(document.mime_type.IndexOf('/') + 1)..]}";
+                if (model.name == null)
+                    model.name = filename;
+
+                _logger.LogInformation("Starting document download with offset - FileName: {FileName}, Size: {SizeMB:F2}MB, Offset: {Offset}",
+                    filename, document.size / (1024.0 * 1024.0), offset);
+
+                if (offset == 0)
+                {
+                    // No offset - use standard download
+                    MemoryStream dest = new MemoryStream();
+                    await client.DownloadFileAsync(document, ms ?? dest, null, model.ProgressCallback);
+                    _logger.LogInformation("Document download completed - FileName: {FileName}", filename);
+                    return ms ?? dest;
+                }
+
+                // Offset-based download using Upload_GetFile API
+                Stream targetStream = ms ?? new MemoryStream();
+                long currentOffset = offset;
+                long totalSize = document.size;
+
+                InputDocument inputFile = document;
+                var location = new InputDocumentFileLocation
+                {
+                    id = inputFile.id,
+                    access_hash = inputFile.access_hash,
+                    file_reference = inputFile.file_reference,
+                    thumb_size = ""
+                };
+
+                _logger.LogInformation("Resuming download from offset {Offset} of {TotalSize} bytes", currentOffset, totalSize);
+
+                while (currentOffset < totalSize)
+                {
+                    int chunkSize = FILESPLITSIZE; // 512KB chunks
+                    if (currentOffset + chunkSize > totalSize)
+                    {
+                        // Adjust last chunk size (must be multiple of 4096 for Telegram API)
+                        long remaining = totalSize - currentOffset;
+                        chunkSize = (int)((remaining + 4095) / 4096 * 4096); // Round up to 4096
+                        if (chunkSize > FILESPLITSIZE)
+                            chunkSize = FILESPLITSIZE;
+                    }
+
+                    Upload_FileBase file = null;
+                    try
+                    {
+                        file = await client.Upload_GetFile(location, currentOffset, limit: chunkSize);
+                    }
+                    catch (RpcException ex) when (ex.Code == 303 && ex.Message == "FILE_MIGRATE_X")
+                    {
+                        _logger.LogWarning("DC migration required, switching to DC {DC}", -ex.X);
+                        client = await client.GetClientForDC(-ex.X, true);
+                        file = await client.Upload_GetFile(location, currentOffset, limit: chunkSize);
+                    }
+                    catch (RpcException ex) when (ex.Code == 400 && ex.Message == "OFFSET_INVALID")
+                    {
+                        _logger.LogError(ex, "OFFSET_INVALID at offset {Offset} - file may have changed", currentOffset);
+                        throw;
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Download error at offset {Offset}", currentOffset);
+                        throw;
+                    }
+
+                    if (file is Upload_File uploadFile)
+                    {
+                        var fileBytes = uploadFile.bytes;
+                        if (fileBytes.Length == 0)
+                        {
+                            _logger.LogInformation("Received empty chunk - download complete at offset {Offset}", currentOffset);
+                            break;
+                        }
+
+                        // Write to stream - for append mode, the stream position should already be at the end
+                        await targetStream.WriteAsync(fileBytes, 0, fileBytes.Length);
+                        currentOffset += fileBytes.Length;
+                        model._transmitted = currentOffset;
+
+                        // Call progress callback
+                        model.ProgressCallback(currentOffset, totalSize);
+
+                        continue;
+                    }
+
+                    throw new InvalidOperationException("Unexpected file type returned from Telegram API.");
+                }
+
+                _logger.LogInformation("Document download with offset completed - FileName: {FileName}, FinalOffset: {Offset}",
+                    filename, currentOffset);
+                return targetStream;
+            }
+            else if (message.message.media is MessageMediaPhoto { photo: Photo photo })
+            {
+                // Photos don't support resume - they're small enough to re-download
+                _logger.LogInformation("Photo download (no resume support) - PhotoId: {PhotoId}", photo.id);
+                var filename = $"{photo.id}.jpg";
+                MemoryStream dest = new MemoryStream();
+                var type = await client.DownloadFileAsync(photo, ms ?? dest, (PhotoSizeBase)null, model.ProgressCallback);
+                dest.Close();
+                return ms ?? dest;
+            }
+
+            return null;
+        }
+
         public async Task<string> DownloadFile(ChatMessages message, string fileName = null, string folder = null, DownloadModel model = null, bool shouldAddToList = false)
         {
             if (model == null)