public DTOResponse <DTOFile> UploadFile(DTOFileUpload uploadFileInfo)
        {
            if (uploadFileInfo.Files.Length == 0)
            {
                return(new DTOResponse <DTOFile>()
                {
                    Code = 400,
                    Message = "You must send an file to upload!"
                });
            }

            try
            {
                var filenameParts = uploadFileInfo.Files.FileName.Split('.');
                var fileExtension = filenameParts[filenameParts.Length - 1];

                var uploadFolder       = uploadFileInfo.Folder ?? "general";
                var localFileName      = uploadFileInfo.Key ?? Guid.NewGuid().ToString();
                var localFinalFileName = $"{localFileName}.{fileExtension}";

                var fileUploadDirPath = $"files/docs/{uploadFolder}/{fileExtension}/";
                if (!Directory.Exists(fileUploadDirPath))
                {
                    Directory.CreateDirectory(fileUploadDirPath);
                }

                var finalFilePath = $"{fileUploadDirPath}{localFinalFileName}";
                using (FileStream filestream = File.Create(finalFilePath))
                {
                    uploadFileInfo.Files.CopyTo(filestream);
                    filestream.Flush();
                }

                FileModel fileToUpload = new FileModel()
                {
                    Key = uploadFileInfo.Key
                };

                if (!string.IsNullOrWhiteSpace(uploadFileInfo.Key))
                {
                    var existingFile = _filesCollection.Find <FileModel>(image => image.Key == uploadFileInfo.Key).FirstOrDefault();
                    if (existingFile != null)
                    {
                        fileToUpload = existingFile;
                    }
                }

                fileToUpload.Folder    = uploadFolder;
                fileToUpload.Path      = finalFilePath;
                fileToUpload.Extension = fileExtension;

                if (string.IsNullOrWhiteSpace(fileToUpload.Id))
                {
                    _filesCollection.InsertOne(fileToUpload);
                }
                else
                {
                    _filesCollection.UpdateOne <FileModel>(file => file.Id == fileToUpload.Id, Builders <FileModel> .Update.Set("Path", fileToUpload.Path).Set("Folder", fileToUpload.Folder).Set("Extension", fileToUpload.Extension));
                }

                this.UploadFileToS3(fileToUpload);

                fileToUpload.Url = _environment.EnvironmentName == "Development" ? $"https://localhost:5001/files/docs/{fileToUpload.Id}" : $"https://api.helpetgroup.net/files/docs/{fileToUpload.Id}";

                _filesCollection.UpdateOne <FileModel>(file => file.Id == fileToUpload.Id, Builders <FileModel> .Update.Set("Url", fileToUpload.Url));

                return(new DTOResponse <DTOFile>()
                {
                    Code = 200,
                    Data = new DTOFile()
                    {
                        Id = fileToUpload.Id,
                        Url = fileToUpload.Url
                    }
                });
            }
            catch (Exception ex)
            {
                return(new DTOResponse <DTOFile>()
                {
                    Code = 400,
                    Message = ex.Message
                });
            }
        }
        public DTOResponse <DTOFile> UploadImage(DTOFileUpload uploadFileInfo)
        {
            if (uploadFileInfo.Files.Length == 0)
            {
                return(new DTOResponse <DTOFile>()
                {
                    Code = 400,
                    Message = "You must send an file to upload!"
                });
            }

            try
            {
                var filenameParts = uploadFileInfo.Files.FileName.Split('.');
                var fileExtension = filenameParts[filenameParts.Length - 1];

                if (fileExtension != "png" && fileExtension != "jpg" && fileExtension != "jpeg")
                {
                    return(new DTOResponse <DTOFile>()
                    {
                        Code = 400,
                        Message = "Uploaded images must be in PNG or JPG formats!"
                    });
                }

                var uploadFolder       = uploadFileInfo.Folder ?? "general";
                var localFileName      = uploadFileInfo.Key ?? Guid.NewGuid().ToString();
                var localFinalFileName = $"{localFileName}.{fileExtension}";

                var imageUploadDirPath = $"files/images/{uploadFolder}/";
                if (!Directory.Exists(imageUploadDirPath))
                {
                    Directory.CreateDirectory(imageUploadDirPath);
                }

                var finalImageFilePath = $"{imageUploadDirPath}{localFinalFileName}";
                using (FileStream filestream = File.Create(finalImageFilePath))
                {
                    uploadFileInfo.Files.CopyTo(filestream);
                    filestream.Flush();
                }

                var thumbnailUploadDirPath = $"files/images/{uploadFolder}/thumbnails/";
                if (!Directory.Exists(thumbnailUploadDirPath))
                {
                    Directory.CreateDirectory(thumbnailUploadDirPath);
                }

                var finalThumbnailFilePath = $"{thumbnailUploadDirPath}{localFinalFileName}";

                try
                {
                    this.GenerateThumbnail(finalImageFilePath, finalThumbnailFilePath, fileExtension == "png" ? "image/png" : "image/jpeg");
                }
                catch (Exception)
                {
                    finalThumbnailFilePath = "";
                }

                ImageModel imageToUpload = new ImageModel()
                {
                    Key = uploadFileInfo.Key
                };

                if (!string.IsNullOrWhiteSpace(uploadFileInfo.Key))
                {
                    var existingImage = _imagesCollection.Find <ImageModel>(image => image.Key == uploadFileInfo.Key).FirstOrDefault();
                    if (existingImage != null)
                    {
                        imageToUpload = existingImage;
                    }
                }

                imageToUpload.Folder        = uploadFolder;
                imageToUpload.MimeType      = fileExtension == "png" ? "image/png" : "image/jpeg";
                imageToUpload.Path          = finalImageFilePath;
                imageToUpload.ThumbnailPath = finalThumbnailFilePath;
                imageToUpload.Extension     = fileExtension;

                if (string.IsNullOrWhiteSpace(imageToUpload.Id))
                {
                    _imagesCollection.InsertOne(imageToUpload);
                }
                else
                {
                    _imagesCollection.UpdateOne <ImageModel>(image => image.Id == imageToUpload.Id, Builders <ImageModel> .Update.Set("Path", imageToUpload.Path).Set("ThumbnailPath", imageToUpload.ThumbnailPath).Set("MimeType", imageToUpload.MimeType).Set("Folder", imageToUpload.Folder).Set("Extension", imageToUpload.Extension));
                }

                this.UploadImageToS3(imageToUpload);

                imageToUpload.Url          = _environment.EnvironmentName == "Development" ? $"https://localhost:5001/files/images/{imageToUpload.Id}" : $"https://api.helpetgroup.net/files/images/{imageToUpload.Id}";
                imageToUpload.ThumbnailUrl = _environment.EnvironmentName == "Development" ? $"https://localhost:5001/files/thumbnails/{imageToUpload.Id}" : $"https://api.helpetgroup.net/files/thumbnails/{imageToUpload.Id}";

                _imagesCollection.UpdateOne <ImageModel>(file => file.Id == imageToUpload.Id, Builders <ImageModel> .Update.Set("Url", imageToUpload.Url).Set("ThumbnailUrl", imageToUpload.ThumbnailUrl));

                return(new DTOResponse <DTOFile>()
                {
                    Code = 200,
                    Data = new DTOFile()
                    {
                        Id = imageToUpload.Id,
                        Url = imageToUpload.Url,
                        ThumbnailUrl = !string.IsNullOrWhiteSpace(finalThumbnailFilePath) ? imageToUpload.ThumbnailUrl : imageToUpload.Url
                    }
                });
            }
            catch (Exception ex)
            {
                return(new DTOResponse <DTOFile>()
                {
                    Code = 400,
                    Message = ex.Message
                });
            }
        }
 public DTOResponse <DTOFile> UploadImage(DTOFileUpload uploadFileInfo)
 {
     return(_filesDomain.UploadImage(uploadFileInfo));
 }