saherelm/xStorageService
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial Commit ...

Browse Source
This commit is contained in:
saherelm
2024-01-25 04:49:52 +03:30
commit d26a1c49fd
17 changed files with 1678 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Providers/XStorageProvider.cs
+924
View File
@@ -0,0 +1,924 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.FileProviders;
using xCommons.Constants;
using xCommons.Extensions;
using xExceptions.Constants;
using xModels.Dtos;
using xStorageService.Constants;
using xStorageService.Helpers;
using xStorageService.Interfaces;
using xStorageService.Models;
namespace xStorageService.Providers {
public partial class XStorageProvider : IXStorageProvider {
public readonly string BasePath;
private readonly XFileType[] ThumbSupprtedTypes = new XFileType[] {
XFileType.Image, XFileType.CoverImage, XFileType.ProfileImasge
};
public IFileProvider FileProvider { get; }
public XStorageHelper StorageHelper { get; }
public IXThumbnailProvider ThumbnailProvider { get; }
public XStorageConfiguration Configuration { get; }
public XStorageProvider (
IFileProvider fileProvider,
XStorageHelper storageHelper,
IXThumbnailProvider thumbnailProvider,
XStorageConfiguration configuration
) {
//
FileProvider = fileProvider;
Configuration = configuration;
StorageHelper = storageHelper;
ThumbnailProvider = thumbnailProvider;
//
BasePath = Path
.Combine (Directory
.GetCurrentDirectory (), Configuration.BaseFolder);
}
//
#region Special Folders Path Getter (s) ...
/// <summary>
/// Get Storage Folder Path
/// </summary>
/// <returns></returns>
public string GetStorageFolderPath () {
return Path.Combine (BasePath, Configuration.Storage);
}
/// <summary>
/// Get Temp Folder Path
/// </summary>
/// <returns></returns>
public string GetTempFolderPath () {
return Path.Combine (GetStorageFolderPath (), Configuration.Temp);
}
/// <summary>
/// Get Uploads Folder Path
/// </summary>
/// <returns></returns>
public string GetUploadsFolderPath () {
return Path.Combine (GetStorageFolderPath (), Configuration.Uploads);
}
/// <summary>
/// Get Widgets Folder Path
/// </summary>
/// <returns></returns>
public string GetWidgetsFolderPath () {
return Path.Combine (GetStorageFolderPath (), Configuration.Widgets);
}
/// <summary>
/// Get Thumb Folder Path
/// </summary>
/// <returns></returns>
public string GetThumbFolderPath () {
return Path.Combine (GetUploadsFolderPath (), Configuration.Thumb);
}
/// <summary>
/// Get Images Folder Path
/// </summary>
/// <returns></returns>
public string GetImageFolderPath () {
return Path.Combine (GetUploadsFolderPath (), Configuration.Image);
}
/// <summary>
/// Get Audios Folder Path
/// </summary>
/// <returns></returns>
public string GetAudioFolderPath () {
return Path.Combine (GetUploadsFolderPath (), Configuration.Audio);
}
/// <summary>
/// Get Videos Folder Path
/// </summary>
/// <returns></returns>
public string GetVideoFolderPath () {
return Path.Combine (GetUploadsFolderPath (), Configuration.Video);
}
/// <summary>
/// Get Documents Folder Path
/// </summary>
/// <returns></returns>
public string GetDocumentFolderPath () {
return Path.Combine (GetUploadsFolderPath (), Configuration.Document);
}
/// <summary>
/// Prepare Full Path to Use for Static Files
/// </summary>
/// <param name="fullPath"></param>
/// <returns></returns>
public string FilePathResolver (string fullPath) {
return fullPath.Replace (BasePath, "");
}
/// <summary>
/// Convert a File Path to Url
/// </summary>
/// <param name="fullPath"></param>
/// <returns></returns>
public string ConvertToProfileImageUrl (string fullPath) {
//
var authority = !Configuration.IdentityAuthority.IsNullOrEmpty () &&
Configuration.IdentityAuthority.EndsWith ("/") ?
Configuration.IdentityAuthority.Substring (0, Configuration.IdentityAuthority.Length - 1) :
Configuration.IdentityAuthority;
//
return $"{authority}{FilePathResolver(fullPath)}";
}
/// <summary>
/// Convert a File Path to Url
/// </summary>
/// <param name="fullPath"></param>
/// <returns></returns>
public string ConvertToFileUrl (string fullPath) {
//
var authority = !Configuration.Authority.IsNullOrEmpty () &&
Configuration.Authority.EndsWith ("/") ?
Configuration.Authority.Substring (0, Configuration.Authority.Length - 1) :
Configuration.Authority;
//
return $"{authority}/{FilePathResolver(fullPath)}";
}
#endregion
//
#region Prepare Storage Structure ...
/// <summary>
/// Check Folder Structure of Storage Area
/// and Create them if not Exists
/// </summary>
public void Prepare () {
//
try {
//
// Storage Folder Path Check ...
if (!IsFolderExists (GetStorageFolderPath ())) {
Directory.CreateDirectory (GetStorageFolderPath ());
}
//
// Temp Folder Path Check ...
if (!IsFolderExists (GetTempFolderPath ())) {
Directory.CreateDirectory (GetTempFolderPath ());
}
//
// Temp Folder Path Check ...
if (!IsFolderExists (GetThumbFolderPath ())) {
Directory.CreateDirectory (GetThumbFolderPath ());
}
//
// Widgets Folder Path Chekc ...
if (!IsFolderExists (GetWidgetsFolderPath ())) {
Directory.CreateDirectory (GetWidgetsFolderPath ());
}
//
// Uploads Folder Path Chekc ...
if (!IsFolderExists (GetUploadsFolderPath ())) {
Directory.CreateDirectory (GetUploadsFolderPath ());
}
//
// Image Folder Path Chekc ...
if (!IsFolderExists (GetImageFolderPath ())) {
Directory.CreateDirectory (GetImageFolderPath ());
}
//
// Music Folder Path Chekc ...
if (!IsFolderExists (GetAudioFolderPath ())) {
Directory.CreateDirectory (GetAudioFolderPath ());
}
//
// Video Folder Path Chekc ...
if (!IsFolderExists (GetVideoFolderPath ())) {
Directory.CreateDirectory (GetVideoFolderPath ());
}
//
// Document Folder Path Chekc ...
if (!IsFolderExists (GetDocumentFolderPath ())) {
Directory.CreateDirectory (GetDocumentFolderPath ());
}
} catch {
XException.StorageServiceInitialFailed.Throw ();
}
//
// Set Temp Folder for Actions ...
ThumbnailProvider.SetTempFolder (GetTempFolderPath ());
}
#endregion
//
#region Validators ...
/// <summary>
/// Detrmines a Path Exists or not
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public bool IsFolderExists (string path) {
return Directory.Exists (path);
}
/// <summary>
/// Check a File Exists or not
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
public bool IsFileExists (string filePath) {
return File.Exists (filePath);
}
/// <summary>
/// Check a File Name Support Thumbnail or not
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public bool IsSupportThumb (string fileName) {
//
if (!fileName.StartsWith (Configuration.FilePrefix)) {
XException.InavlidFile.Throw ();
}
//
var fileType = StorageHelper.GetType (fileName);
return IsSupportThumb (fileType);
}
/// <summary>
/// Check a FileType Support Thumbnail or not
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public bool IsSupportThumb (XFileType type) {
return ThumbSupprtedTypes.Contains (type);
}
/// <summary>
/// Validate a File Exists or not
/// </summary>
/// <param name="filePath"></param>
public void ValidateFileExists (string filePath) {
//
if (!IsFileExists (filePath)) {
XException.NotFound.Throw ();
}
}
/// <summary>
/// Validate a File Model with it's Related Physical File
/// </summary>
/// <param name="file"></param>
public void ValidateFileModel (XFileDto file) {
//
// Validate Args ...
if (file == null) {
XException.InvalidArgs.Throw ();
}
//
// Retrieve Full File Path ...
var fileFullPath = file.Path;
if (fileFullPath.IsNullOrEmpty ()) {
XException.InavlidFile.Throw ();
}
//
// Retrieve is File Exists or not ...
var isPhysicalFileExists = IsFileExists (file.Path);
if (!isPhysicalFileExists) {
XException.NotFound.Throw ();
}
}
/// <summary>
/// Validate File for Upload
/// </summary>
/// <param name="file"></param>
public void ValidateFile (IFormFile file) {
//
// Validate Args ...
if (file == null) {
XException.InvalidArgs.Throw ();
}
//
// Check File Size not Zero ...
if (file.Length == 0) {
XException.EmptyFile.Throw ();
}
//
// Check File Max Size ...
if (file.Length > Configuration.MaxFileSize) {
XException.MaxFileSizeExceeded.Throw ();
}
}
/// <summary>
/// Validate a Collection of IFormFile
/// </summary>
/// <param name="files"></param>
public void ValidateFiles (IFormFileCollection files) {
//
// Validate Args ...
if (!files.HasChild ()) {
XException.InvalidArgs.Throw ();
}
//
files.ToList ()
.ForEach (f => ValidateFile (f));
}
/// <summary>
/// Validate File for Profile Image
/// </summary>
/// <param name="file"></param>
public void ValidateProfileImage (IFormFile file) {
//
// Check File Validation ...
// since Args Checked in File Validation, there is no need to
// double check it ...
ValidateFile (file);
//
// Check File Type ...
var fileType = GetFileType (file.FileName);
if (fileType != XFileType.Image) {
XException.UnsupportedFileType.Throw ();
}
}
#endregion
//
#region Generators ...
/// <summary>
/// Generate New File
/// </summary>
/// <returns></returns>
public string NewFileName () {
return Configuration.FilePrefix + Guid.NewGuid ().ToString ().ToLower ();
}
/// <summary>
/// Retrieve Related Thumnail File
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public string GenerateThumbName (string fileName) {
//
if (!IsSupportThumb (fileName)) {
XException.UnsupportedFileType.Throw ();
}
//
return fileName.Replace (Configuration.FilePrefix, Configuration.ThumbPrefix);
}
/// <summary>
/// Get a New FileName with Extension based on Given fileName
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public string GetNewFileName (string fileName) {
//
// Validate Args ...
if (fileName.IsNullOrEmpty ()) {
XException.InvalidArgs.Throw ();
}
//
var fileExt = GetFileExtension (fileName);
var newFileNameWithoutExt = NewFileName ();
//
// Generate New File Name ...
var newFileName = string.Format ("{0}{1}", newFileNameWithoutExt, fileExt);
//
return newFileName;
}
#endregion
//
#region Tools Actions ...
/// <summary>
/// Extract a FileName's Extension
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public string GetFileExtension (string fileName) {
//
var result = StorageHelper.GetFileExtension (fileName);
if (result.IsNullOrEmpty ()) {
XException.InvalidArgs.Throw ();
}
//
return result;
}
/// <summary>
/// Extract a FileName's Without it's Extension
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public string GetFileNameWithoutExtension (string fileName) {
//
var result = StorageHelper.GetFileNameWithoutExtension (fileName);
if (result.IsNullOrEmpty ()) {
XException.InvalidArgs.Throw ();
}
//
return result;
}
/// <summary>
/// Get file Extension of Specified File Name
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public FileExtensions GetFileExtensionType (string fileName) {
//
var fileExt = GetFileExtension (fileName);
if (fileExt.IsNullOrEmpty ()) {
XException.InvalidData.Throw ();
}
//
var result = StorageHelper.GetExtensionType (fileExt);
if (result == -1) {
XException.UnsupportedFileType.Throw ();
}
//
return (FileExtensions) result;
}
/// <summary>
/// Return File Type of Specific File Name
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public XFileType GetFileType (string fileName) {
//
var fileExtension = GetFileExtensionType (fileName);
return GetFileType (fileExtension);
}
/// <summary>
/// Return File Type of Specific Extension
/// </summary>
/// <param name="fileExtension"></param>
/// <returns></returns>
public XFileType GetFileType (FileExtensions fileExtension) {
return StorageHelper.GetType ((int) fileExtension);
}
/// <summary>
/// Retrieve Full Path of thumbnail File
/// </summary>
/// <param name="thumFileName"></param>
/// <returns></returns>
public string GetThumbnailFileFullPath (string thumFileName) {
//
if (!thumFileName.StartsWith (Configuration.ThumbPrefix)) {
XException.InavlidFile.Throw ();
}
//
return Path.Combine (GetThumbFolderPath (), thumFileName);
}
/// <summary>
/// Retrieve a File Thumbnail Path if Supported
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public string GetRelatedThumbnailFullPath (string fileName) {
//
var thumbName = GenerateThumbName (fileName);
return GetThumbnailFileFullPath (thumbName);
}
/// <summary>
/// Retrieve Special File Type's Folder Path
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public string GetFileTypeFolderPath (XFileType type) {
//
// Retrieve Folder Path Based on file ...
switch (type) {
case XFileType.Image:
case XFileType.CoverImage:
case XFileType.ProfileImasge:
return GetImageFolderPath ();
case XFileType.Audio:
return GetAudioFolderPath ();
case XFileType.Video:
return GetVideoFolderPath ();
case XFileType.Document:
default:
return GetDocumentFolderPath ();
}
}
/// <summary>
/// Retrieve a File's Folder path
/// </summary>
/// <param name="fileName"></param>
/// <param name="isTemp"></param>
/// <param name="isWidget"></param>
/// <returns></returns>
public string GetFileFolderPath (
string fileName,
bool isTemp = false,
bool isWidget = false) {
//
// Validate Args ...
if (fileName.IsNullOrEmpty ()) {
XException.InvalidArgs.Throw ();
}
//
var fileType = GetFileType (fileName);
//
var folderPath = "";
//
// if isTemp equals true
// ignore file type and return Temp Folder ...
if (isTemp) {
folderPath = GetTempFolderPath ();
}
//
// if isWidget equals true and isTemp equals false
// ignore file type and return Widget's Folder ...
if (isWidget && !isTemp) {
folderPath = GetWidgetsFolderPath ();
}
//
// if both isTemp and isWidget equals false
// which is the default state, retrieve proper folder path
// based on file type and return it ...
if (!isTemp && !isWidget) {
folderPath = GetFileTypeFolderPath (fileType);
}
//
// Check folderPath restrict to have Value ...
if (folderPath.IsNullOrEmpty ()) {
XException.InvalidData.Throw ();
}
//
// return result ...
return folderPath;
}
/// <summary>
/// Retrieve a Full path of a File
/// </summary>
/// <param name="fileName"></param>
/// <param name="isTemp"></param>
/// <param name="isWidget"></param>
/// <returns></returns>
public string GetFileFullPath (
string fileName,
bool isTemp = false,
bool isWidget = false
) {
//
var folderPath = GetFileFolderPath (
fileName,
isTemp : isTemp,
isWidget : isWidget
);
//
if (folderPath.IsNullOrEmpty ()) {
XException.ActionFailed.Throw ();
}
//
return Path.Combine (folderPath, fileName);
}
/// <summary>
/// Save a File into Storage Based on it's Type
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task<string> SaveFileAsync (
IFormFile file,
bool isTemp = false,
bool isWidget = false) {
//
// Validate Args ...
ValidateFile (file);
//
// Extract and Generate required Data ...
var fileName = GetNewFileName (file.FileName);
var folderPath = GetFileFolderPath (file.FileName, isTemp, isWidget);
var fileFullPath = Path.Combine (folderPath, fileName);
//
// Save File ...
using (var stream = new FileStream (fileFullPath, FileMode.Create)) {
await file.CopyToAsync (stream);
}
//
// Since all Required data can be Generated based on
// a simple file Name, there is no need to return additional
// data as result ...
return fileName;
}
/// <summary>
/// Delete a Physical File by Validate it's Exists
/// </summary>
/// <param name="fileFullPath"></param>
public void DeleteFile (
string fileFullPath,
bool forceFileExists = true,
Exception exception = null) {
//
// Validate Args ...
if (!forceFileExists &&
fileFullPath.IsNullOrEmpty ()) {
XException.InvalidArgs.Throw ();
}
//
// Prepare Default Exception ...
if (exception == null) {
exception = XException.NotFound.ToException ();
}
//
// Check File Exists ...
var isFileExists = File.Exists (fileFullPath);
if (forceFileExists &&
!isFileExists) {
XException.NotFound.Throw ();
}
//
// Handle Prevent Error when forceFileExists false
// and File doesn't Exists ...
if (!forceFileExists &&
!isFileExists) {
return;
}
//
File.Delete (fileFullPath);
}
/// <summary>
/// Remove a List of Physical Files Path
/// and return Un Removable Files ...
/// </summary>
/// <param name="fileFullPaths"></param>
/// <param name="forceFileExists"></param>
/// <param name="exception"></param>
/// <returns></returns>
public ICollection<string> DeleteFiles (
ICollection<string> fileFullPaths,
bool forceFileExists = true,
Exception exception = null
) {
//
if (exception.IsNull ()) {
exception = XException.NotFound.ToException ();
}
//
var result = fileFullPaths.Where (f => !IsFileExists (GetFileFullPath (f))).ToList ();
if (forceFileExists && result.HasChild ()) {
throw exception;
}
//
var existsFile = fileFullPaths.Where (f => IsFileExists (f)).ToList ();
existsFile.ForEach (f => {
DeleteFile (
f,
forceFileExists : forceFileExists,
exception : exception
);
});
//
return fileFullPaths.Except (existsFile).ToList ();
}
/// <summary>
/// Create Thumbnail based on FileName.Ext
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public async Task CreateThumbnail (string fileName) {
//
if (fileName.IsNullOrEmpty ()) {
return;
}
//
await Task.Run (() => {
//
var fileFullPath = GetFileFullPath (fileName);
if (!IsFileExists (fileFullPath)) {
XException.NotFound.Throw ();
}
//
var thumbFileName = GenerateThumbName (fileName);
var thumbFullPath = GetThumbnailFileFullPath (thumbFileName);
//
ThumbnailProvider.ResizeImage (
fileFullPath,
thumbFullPath,
Configuration.ThumbSize,
Configuration.ThumbQuality
);
});
}
/// <summary>
/// Create Thumbnail based on XFile model
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task CreateThumbnail (XFileDto file) {
//
await CreateThumbnail (file.Name);
}
// /// <summary>
// /// Create Thumbnail based on XFile model
// /// </summary>
// /// <param name="file"></param>
// /// <returns></returns>
// public async Task CreateThumbnail (XFile file) {
// //
// await CreateThumbnail (file.Name);
// }
/// <summary>
/// Save and Create a Thumbnail For Profile Image
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task<XFileResult> HandleProfileImageSave (IFormFile file) {
//
ValidateProfileImage (file);
//
var savedFileName = await SaveFileAsync (file, isTemp : false, isWidget : false);
var thumbFileName = GenerateThumbName (savedFileName);
//
var savedFileFullPath = GetFileFullPath (savedFileName);
var thumbFullPath = GetThumbnailFileFullPath (thumbFileName);
//
await CreateThumbnail (savedFileName);
//
return new XFileResult {
Name = file.Name,
FileName = savedFileName,
FilePath = ConvertToProfileImageUrl (savedFileFullPath),
Thmbnail = thumbFileName,
ThmbnailPath = ConvertToProfileImageUrl (thumbFullPath)
};
}
/// <summary>
/// Handle File Upload with Support of Thumbnails ...
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task<XFileResult> HandleFileSave (IFormFile file) {
//
ValidateFile (file);
//
var savedFileName = await SaveFileAsync (file, isTemp : false, isWidget : false);
//
var savedFileFullPath = GetFileFullPath (savedFileName);
//
var thumbFileName = "";
var thumbFullPath = "";
var fileType = GetFileType (savedFileName);
if (fileType.IsImageKind ()) {
//
thumbFileName = GenerateThumbName (savedFileName);
thumbFullPath = GetThumbnailFileFullPath (thumbFileName);
//
await CreateThumbnail (savedFileName);
}
//
var result =
new XFileResult {
Name = file.FileName,
FileName = savedFileName,
FilePath = ConvertToFileUrl (savedFileFullPath),
Thmbnail = thumbFileName,
ThmbnailPath = ConvertToFileUrl (thumbFullPath),
};
//
return result;
}
/// <summary>
/// Handle File Upload with Support of Thumbnails ...
/// </summary>
/// <param name="files"></param>
/// <returns></returns>
public async Task<IEnumerable<XFileResult>> HandleFilesSave (IFormFileCollection files) {
//
ValidateFiles (files);
//
var result = new Collection<XFileResult> ();
foreach (var file in files) {
//
var savedFileName = await SaveFileAsync (file, isTemp : false, isWidget : false);
//
var savedFileFullPath = GetFileFullPath (savedFileName);
//
var thumbFileName = "";
var thumbFullPath = "";
var fileType = GetFileType (savedFileName);
if (fileType.IsImageKind ()) {
//
thumbFileName = GenerateThumbName (savedFileName);
thumbFullPath = GetThumbnailFileFullPath (thumbFileName);
//
await CreateThumbnail (savedFileName);
}
//
result.Add (
new XFileResult {
Name = file.FileName,
FileName = savedFileName,
FilePath = ConvertToFileUrl (savedFileFullPath),
Thmbnail = thumbFileName,
ThmbnailPath = ConvertToFileUrl (thumbFullPath),
});
}
//
return result;
}
#endregion
}
}
Providers/XThumbnailProvider.cs
+34
View File
@@ -0,0 +1,34 @@
using ImageMagick;
using xCommons.Extensions;
using xStorageService.Interfaces;
using xStorageService.Models;
namespace xStorageService.Providers {
public partial class XThumbnailProvider : IXThumbnailProvider {
public void SetTempFolder (string folder) {
MagickNET.SetTempDirectory (folder);
}
public XImageInfo GetImageInfo (string filePath) {
//
MagickImageInfo info = new MagickImageInfo (filePath);
return info.MapConvert<XImageInfo, MagickImageInfo> ();
}
public void ResizeImage (
string filePath,
string resizedFilePath,
int size,
int quality
) {
//
using (var image = new MagickImage (filePath)) {
//
image.Resize (size, size);
image.Strip ();
image.Quality = quality;
image.Write (resizedFilePath);
}
}
}
}