internal: Develop to main

.github/workflows/docker-image.yml

@@ -1,4 +1,4 @@
-name: Docker Image CI
+name: Docker Image CI (Dev)
 
 on:
   push:
@@ -12,17 +12,30 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+
+    - name: Generate version
+      id: version
+      run: |
+        # Generate dev version: 0.0.0-dev.YYYYMMDD.HHMMSS.shortsha
+        DATE_VERSION=$(date +%Y%m%d.%H%M%S)
+        SHORT_SHA=$(echo ${{ github.sha }} | cut -c1-7)
+        VERSION="0.0.0-dev.${DATE_VERSION}.${SHORT_SHA}"
+        echo "version=$VERSION" >> $GITHUB_OUTPUT
+        echo "Generated version: $VERSION"
+
     - name: 'Login to GitHub Container Registry'
       uses: docker/login-action@v3
       with:
         registry: ghcr.io
         username: ${{github.actor}}
         password: ${{secrets.GHCR}}
+
     - name: Build and Push the Docker image
       run: |
-        date_ref=$(date +%s)
-        docker build ./TelegramDownloader -f ./TelegramDownloader/Dockerfile --tag ghcr.io/mateof/telegramfilemanager:dev_$date_ref
-        IMAGE_ID=$(docker images | grep ghcr.io/mateof/telegramfilemanager | awk '{print $3}')
-        docker tag $IMAGE_ID ghcr.io/mateof/telegramfilemanager:dev_latest
-        docker push ghcr.io/mateof/telegramfilemanager:dev_$date_ref
+        VERSION=${{ steps.version.outputs.version }}
+        docker build ./TelegramDownloader -f ./TelegramDownloader/Dockerfile \
+          --build-arg VERSION=$VERSION \
+          --tag ghcr.io/mateof/telegramfilemanager:dev_$VERSION \
+          --tag ghcr.io/mateof/telegramfilemanager:dev_latest
+        docker push ghcr.io/mateof/telegramfilemanager:dev_$VERSION
         docker push ghcr.io/mateof/telegramfilemanager:dev_latest

.github/workflows/release-docker-image.yml

@@ -1,4 +1,4 @@
-name: Docker Image CI
+name: Docker Image CI (Release)
 
 on:
   push:
@@ -12,16 +12,28 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+
+    - name: Extract version from tag
+      id: version
+      run: |
+        # Remove 'v' prefix from tag (v1.2.3 -> 1.2.3)
+        VERSION=${GITHUB_REF_NAME#v}
+        echo "version=$VERSION" >> $GITHUB_OUTPUT
+        echo "Extracted version: $VERSION"
+
     - name: 'Login to GitHub Container Registry'
       uses: docker/login-action@v3
       with:
         registry: ghcr.io
         username: ${{github.actor}}
         password: ${{secrets.GHCR}}
+
     - name: Build and Push the Docker image
       run: |
-        docker build ./TelegramDownloader -f ./TelegramDownloader/Dockerfile --tag ghcr.io/mateof/telegramfilemanager:latest --build-arg tag=${{github.ref_name}}
-        IMAGE_ID=$(docker images | grep ghcr.io/mateof/telegramfilemanager | awk '{print $3}')
-        docker tag $IMAGE_ID ghcr.io/mateof/telegramfilemanager:${{github.ref_name}}
-        docker push ghcr.io/mateof/telegramfilemanager:latest
+        VERSION=${{ steps.version.outputs.version }}
+        docker build ./TelegramDownloader -f ./TelegramDownloader/Dockerfile \
+          --build-arg VERSION=$VERSION \
+          --tag ghcr.io/mateof/telegramfilemanager:${{github.ref_name}} \
+          --tag ghcr.io/mateof/telegramfilemanager:latest
         docker push ghcr.io/mateof/telegramfilemanager:${{github.ref_name}}
+        docker push ghcr.io/mateof/telegramfilemanager:latest

README.md

@@ -38,6 +38,7 @@ services:
       api_id: ""
       hash_id: ""
       DOTNET_HOSTBUILDER__RELOADCONFIGONCHANGE: false
+      DOTNET_CLI_TELEMETRY_OPTOUT: true
     restart: unless-stopped
     depends_on:
       - mongodb_container

TelegramDownloader/Data/FileService.cs

@@ -557,6 +557,52 @@ public async Task oneItemDeleteAsync(string dbName, Syncfusion.Blazor.FileManage
 
         }
 
+        public async Task<FileManagerResponse<Syncfusion.Blazor.FileManager.FileManagerDirectoryContent>> CopyOrMoveItems(string dbName, Syncfusion.Blazor.FileManager.FileManagerDirectoryContent[] files, string targetPath, Syncfusion.Blazor.FileManager.FileManagerDirectoryContent targetData, bool isCopy)
+        {
+            try
+            {
+                FileManagerResponse<Syncfusion.Blazor.FileManager.FileManagerDirectoryContent> fm = new FileManagerResponse<Syncfusion.Blazor.FileManager.FileManagerDirectoryContent>();
+                var lista = new List<Syncfusion.Blazor.FileManager.FileManagerDirectoryContent>();
+                foreach (var item in files)
+                {
+                    if (!item.IsFile)
+                    {
+                        var result = await copyAllDirectoryFiles(dbName, item.Id, targetData, targetPath + item.Name + "/");
+                        lista.Add(result.toFileManagerContentInCopy());
+                        if (!isCopy)
+                        {
+                            await _db.deleteEntry(dbName, item.Id);
+                        }
+                    }
+                    else
+                    {
+                        var result = await _db.copyItem(dbName, item.Id, targetData, targetPath, item.IsFile);
+                        lista.Add(result.toFileManagerContentInCopy());
+                        if (!isCopy)
+                        {
+                            await _db.deleteEntry(dbName, item.Id);
+                        }
+                    }
+                    await _db.addBytesToFolder(dbName, item.ParentId, item.Size);
+                }
+                fm.Files = lista;
+                return fm;
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Error on CopyOrMoveItems");
+                if (e is MongoWriteException ex)
+                {
+                    if (ex.WriteError.Category == ServerErrorCategory.DuplicateKey)
+                    {
+                        NotificationModel nm = new NotificationModel();
+                        nm.sendEvent(new Notification("The file exist in the directory", "Duplicate", NotificationTypes.Error));
+                    }
+                }
+                throw e;
+            }
+        }
+
         private async Task<BsonFileManagerModel> copyAllDirectoryFiles(string dbName, string idfolder, Syncfusion.Blazor.FileManager.FileManagerDirectoryContent target, string targetPath, bool isCopy = true)
         {
             var result = await _db.copyItem(dbName, idfolder, target, targetPath, false);
@@ -1027,6 +1073,11 @@ public async Task importSharedData(ShareFilesModel sfm, GenericNotificationProgr
             return (await _db.createEntry(dbName, await _db.toBasonFile(args.Path, args.FolderName, args.ParentFolder))).Select(x => x.toFileManagerContent()).ToList();
         }
 
+        public async Task<List<Syncfusion.Blazor.FileManager.FileManagerDirectoryContent>> createFolder(string dbName, string path, string folderName, Syncfusion.Blazor.FileManager.FileManagerDirectoryContent? parentFolder)
+        {
+            return (await _db.createEntry(dbName, await _db.toBasonFile(path, folderName, parentFolder))).Select(x => x.toFileManagerContent()).ToList();
+        }
+
         public async Task CreateDatabase(string id)
         {
             if (_ts.checkChannelExist(id))
@@ -1444,10 +1495,11 @@ public async Task UploadFileFromServer(string dbName, string currentPath, List<S
                     // if file or folder does not exist, it will be created
                     if ((await _db.getFileByPath(dbName, System.IO.Path.Combine(currentPath, file.Name))) == null)
                         await _db.createEntry(dbName, model);
+                    if (!parent.HasChild)
+                        await _db.setDirectoryHasChild(dbName, parent.Id);
                     if (file.IsFile)
                     {
                         await _db.addBytesToFolder(dbName, model.ParentId, model.Size);
-                        await _db.setDirectoryHasChild(dbName, parent.Id);
                         if (idt != null) idt.AddOne(file.Size);
                     }
                     else
@@ -1535,6 +1587,7 @@ private string GetMimeType(string fileName)
 
         public async Task refreshChannelFIles(string channelId, bool force = false)
         {
+            int totalNewMessages = 0;
             refreshMutex.WaitOne();
             refreshChannelList.Add(channelId);
             refreshMutex.ReleaseMutex();
@@ -1590,21 +1643,23 @@ public async Task refreshChannelFIles(string channelId, bool force = false)
                     model.isSplit = false;
                     model.isEncrypted = false;
                     await _db.createEntry(channelId, model);
+                    totalNewMessages++;
                 }
             }
             refreshMutex.WaitOne();
             refreshChannelList.Remove(channelId);
             refreshMutex.ReleaseMutex();
-            _logger.LogInformation($"Finish Refresh channel with id: {channelId}");
+            _logger.LogInformation($"Finish Refresh channel with id: {channelId} with {totalNewMessages} new files added.");
 
             // Fix for CS1739: Removed the invalid 'autoHide' parameter and replaced it with the correct property assignment.
             ToastMessage tm = new ToastMessage
             {
                 Type = ToastType.Success,
                 IconName = IconName.CheckCircle,
                 Title = "Refresh channel files",
-                Message = "Files channel has been refreshed",
+                Message = $"Files channel has been refreshed with {totalNewMessages} new files added.",
                 AutoHide = true
+
             };
             _toastService.Notify(tm);
         }
@@ -1769,6 +1824,13 @@ public async Task<List<BsonFileManagerModel>> getTelegramFolders(string dbName,
             return result;
         }
 
+        public async Task<List<BsonFileManagerModel>> getTelegramFoldersByParentId(string dbName, string? parentId)
+        {
+            var result = await _db.getFoldersByParentId(dbName, parentId);
+
+            return result;
+        }
+
         private async Task<List<FolderModel>> getTelegramSubfolders(string id, List<BsonFileManagerModel> listFolders, string prevPath)
         {
             List<FolderModel> node = new List<FolderModel>();
@@ -1841,9 +1903,20 @@ private async Task<List<ExpandoObject>> AddChildRecords(string id, string parent
                 var childItem = fileDetails.Count > 0 && fileDetails[0] != null ? fileDetails[0] : Data
                 .Where(x => x.FilePath + "/" == path).First().toFileManagerContent();
                 response.CWD = childItem;
-                response.Files = Data
-                    .Where(x => x.ParentId == childItem.Id).Select(x => x.toFileManagerContent()).ToList();
 
+                // First try to find children in the query result (by ParentId)
+                var files = Data.Where(x => x.ParentId == childItem.Id).ToList();
+
+                // If no children found in query result, do a separate query by ParentId
+                // This handles the case where children's FilterPath format doesn't match the query path
+                if (files.Count == 0 && !string.IsNullOrEmpty(childItem.Id))
+                {
+                    files = collectionName == null
+                        ? await _db.getFilesByParentId(dbName, childItem.Id)
+                        : await _db.getFilesByParentId(dbName, childItem.Id, collectionName);
+                }
+
+                response.Files = files.Select(x => x.toFileManagerContent()).ToList();
             }
             await Task.Yield();
             return response;
@@ -1980,5 +2053,10 @@ private async Task mergeFileStreamAsync(List<string> pathList, string destName)
                 }
             _logger.LogInformation("File merge completed - DestName: {DestName}", destName);
         }
+
+        public virtual Task<int> PreloadFilesToTemp(string channelId, List<Syncfusion.Blazor.FileManager.FileManagerDirectoryContent> items)
+        {
+            throw new NotImplementedException("PreloadFilesToTemp is implemented in FileServiceV2");
+        }
     }
 }

TelegramDownloader/Data/FileServiceV2.cs

@@ -170,7 +170,141 @@ public async Task DownloadFileNowV2(string dbName, int messageId, string destPat
             {
                 await _ts.DownloadFileAndReturn(cm, ms: fs, model: model);
             }
-
+
+        }
+
+        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);
+            NotificationModel nm = new NotificationModel();
+            int preloadedCount = 0;
+            string tempPath = System.IO.Path.Combine(TEMPDIR, "_temp");
+            Directory.CreateDirectory(tempPath);
+
+            try
+            {
+                nm.sendEvent(new Notification($"Starting preload of {items.Count} items to cache", "Preload", NotificationTypes.Info));
+
+                // Collect all files to preload (including files inside folders)
+                var filesToPreload = new List<BsonFileManagerModel>();
+                await CollectFilesForPreloadV2(channelId, items, filesToPreload);
+
+                _logger.LogInformation("Collected {Count} files to preload", filesToPreload.Count);
+                nm.sendEvent(new Notification($"Found {filesToPreload.Count} files to preload", "Preload", NotificationTypes.Info));
+
+                foreach (var file in filesToPreload)
+                {
+                    try
+                    {
+                        // Build the temp file name: {channelId}-{MessageId}-{fileName}
+                        string tempFileName = $"{channelId}-{file.MessageId}-{file.Name}";
+                        string tempFilePath = System.IO.Path.Combine(tempPath, tempFileName);
+
+                        // Check if file already exists and is complete
+                        if (File.Exists(tempFilePath))
+                        {
+                            var existingFile = new System.IO.FileInfo(tempFilePath);
+                            if (existingFile.Length >= file.Size)
+                            {
+                                _logger.LogInformation("File already preloaded: {FileName}", file.Name);
+                                preloadedCount++;
+                                continue;
+                            }
+                            // File exists but incomplete, delete and re-download
+                            File.Delete(tempFilePath);
+                        }
+
+                        // Download file to temp
+                        _logger.LogInformation("Preloading file: {FileName} (MessageId: {MessageId})", file.Name, file.MessageId);
+
+                        if (file.isSplit)
+                        {
+                            // Handle split files
+                            await PreloadSplitFilesToTempV2(channelId, file, tempFilePath);
+                        }
+                        else
+                        {
+                            await downloadFromTelegramV2(channelId, (int)file.MessageId, tempFilePath, file);
+                        }
+
+                        preloadedCount++;
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Error preloading file: {FileName}", file.Name);
+                    }
+                }
+
+                nm.sendEvent(new Notification($"Preload completed: {preloadedCount} files cached", "Preload", NotificationTypes.Success));
+                _logger.LogInformation("Preload completed - FilesPreloaded: {Count}", preloadedCount);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error during preload to temp");
+                nm.sendEvent(new Notification($"Error during preload: {ex.Message}", "Preload Error", NotificationTypes.Error));
+            }
+
+            return preloadedCount;
+        }
+
+        private async Task CollectFilesForPreloadV2(string channelId, List<FileManagerDirectoryContent> items, List<BsonFileManagerModel> filesToPreload)
+        {
+            foreach (var item in items)
+            {
+                if (item.IsFile)
+                {
+                    // Get the file details from database
+                    var dbFile = await _db.getFileById(channelId, item.Id);
+                    if (dbFile != null && dbFile.MessageId != null)
+                    {
+                        filesToPreload.Add(dbFile);
+                    }
+                }
+                else
+                {
+                    // It's a folder - get all files inside recursively
+                    await CollectFilesInFolderRecursiveV2(channelId, item.Id, filesToPreload);
+                }
+            }
+        }
+
+        private async Task CollectFilesInFolderRecursiveV2(string channelId, string folderId, List<BsonFileManagerModel> filesToPreload)
+        {
+            // Get all items in this folder
+            var children = await _db.getFilesByParentId(channelId, folderId);
+
+            foreach (var child in children)
+            {
+                if (child.IsFile)
+                {
+                    if (child.MessageId != null)
+                    {
+                        filesToPreload.Add(child);
+                    }
+                }
+                else
+                {
+                    // Recurse into subfolder
+                    await CollectFilesInFolderRecursiveV2(channelId, child.Id, filesToPreload);
+                }
+            }
+        }
+
+        private async Task PreloadSplitFilesToTempV2(string channelId, BsonFileManagerModel file, string destPath)
+        {
+            _logger.LogInformation("Preloading split file V2 - FileName: {FileName}, Parts: {Parts}", file.Name, file.ListMessageId?.Count ?? 0);
+
+            if (File.Exists(destPath))
+            {
+                File.Delete(destPath);
+            }
+
+            int i = 1;
+            foreach (int messageId in file.ListMessageId)
+            {
+                await downloadFromTelegramV2(channelId, messageId, destPath, file, true, destPath, i);
+                i++;
+            }
         }
 
     }