Exemple #1
0
    private async Task UpdateStatus(BitFileUploadStatus uploadStatus, int index)
    {
        if (Files is null)
        {
            return;
        }

        if (index < 0)
        {
            UploadStatus = uploadStatus;

            var files = Files.Where(c => c.Status != BitFileUploadStatus.NotAllowed).ToArray();
            foreach (var file in files)
            {
                file.Status = uploadStatus;
            }

            await OnChange.InvokeAsync(files);
        }
        else
        {
            if (Files[index].Status != uploadStatus)
            {
                Files[index].Status = uploadStatus;
                await OnChange.InvokeAsync(new[] { Files[index] });
            }

            if (uploadStatus == BitFileUploadStatus.InProgress)
            {
                await OnProgress.InvokeAsync(Files[index]);
            }

            if (uploadStatus == BitFileUploadStatus.Completed)
            {
                await OnUploadComplete.InvokeAsync(Files[index]);
            }

            if (uploadStatus == BitFileUploadStatus.Removed)
            {
                await OnRemoveComplete.InvokeAsync(Files[index]);
            }

            if (uploadStatus == BitFileUploadStatus.Failed)
            {
                await OnUploadFailed.InvokeAsync(Files[index]);
            }

            if (uploadStatus == BitFileUploadStatus.RemoveFailed)
            {
                await OnRemoveFailed.InvokeAsync(Files[index]);
            }
        }
    }
Exemple #2
0
        protected async Task <bool> Sync(string[] images, object sender)
        {
            try
            {
                foreach (var filePath in images)
                {
                    var isUploaded    = false;
                    var tags          = filePath.GetFileTags();
                    var fileNotExists = !DirectoryHelper.FileExists(Path.Combine(
                                                                        DirectoryHelper.UploadedImagesPath,
                                                                        filePath.GetFileName()));
                    var path = DirectoryHelper.FailedImagesPath;
                    if (fileNotExists)
                    {
                        path = DirectoryHelper.UploadedImagesPath;
                        try
                        {
                            var fileName = filePath.GetFileName();
                            if (tempFileName.Equals(fileName))
                            {
                                return(false);
                            }
                            tempFileName = fileName;
                            using (var img = Image.FromFile(filePath))
                            {
                                isUploaded = await Upload(ImageToByteArray(img), fileName, tags);
                            }
                        }
                        catch (Exception e)
                        {
                            LoggingHelper.Save(e);
                            isUploaded = false;
                        }
                    }

                    var done = fileNotExists && isUploaded;
                    if (done)
                    {
                        OnFileUploaded?.Invoke(sender, new ImageEventArgs
                        {
                            ImagePath  = filePath,
                            TargetPath = path
                        });
                    }
                    else
                    {
                        OnUploadFailed?.Invoke(sender, new ImageEventArgs
                        {
                            ImagePath  = filePath,
                            TargetPath = path
                        });
                    }
                    OnAllFilesUploaded?.Invoke(sender, EventArgs.Empty);
                }

                return(true);
            }
            catch (Exception ex)
            {
                LoggingHelper.Save(ex);
                return(false);
            }
        }