added fs files crud; simplified ILuCrudInterface; tests; added LuPaginatedDbo helpers

Luticate2.Auth/project.json

@@ -4,7 +4,7 @@
         "debugType": "portable"
     },
     "dependencies": {
-        "Luticate2.Utils": "0.3.*"
+        "Luticate2.Utils": "0.4.*"
     },
     "frameworks": {
         "netcoreapp1.0": {

Luticate2.Utils/Business/LuCrudBusiness.cs

@@ -1,11 +1,9 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using Luticate2.Utils.Dbo.Basic;
-using Luticate2.Utils.Dbo.Filter;
-using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
+using Luticate2.Utils.Utils;
 
 namespace Luticate2.Utils.Business
 {
@@ -19,7 +17,7 @@ namespace Luticate2.Utils.Business
     {
         protected readonly TDataAccess DataAccess;
 
-        private readonly LuNotificationsBusiness _notificationsBusiness;
+        private readonly ILuNotificationsBusiness _notificationsBusiness;
 
         protected virtual string EntityType { get; set; }
 
@@ -29,7 +27,7 @@ namespace Luticate2.Utils.Business
 
         protected virtual Func<string, TDboRead, bool> NotifyDeleteFilter { get; set; }
 
-        protected LuCrudBusiness(TDataAccess dataAccess, LuNotificationsBusiness notificationsBusiness)
+        protected LuCrudBusiness(TDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness)
         {
             DataAccess = dataAccess;
             _notificationsBusiness = notificationsBusiness;
@@ -40,21 +38,6 @@ namespace Luticate2.Utils.Business
             return LuResult<TDboCreate>.Ok(obj);
         }
 
-        protected virtual LuResult<IEnumerable<TDboCreate>> CheckAdd(IEnumerable<TDboCreate> objs)
-        {
-            var list = new List<TDboCreate>();
-            foreach (var obj in objs)
-            {
-                var res = CheckAdd(obj);
-                if (!res)
-                {
-                    return res.To<IEnumerable<TDboCreate>>();
-                }
-                list.Add(res.Data);
-            }
-            return LuResult<IEnumerable<TDboCreate>>.Ok(list);
-        }
-
         protected virtual LuResult<TDboUpdate> CheckEdit(TDboRead dbo, TDboUpdate update)
         {
             return LuResult<TDboUpdate>.Ok(update);
@@ -71,16 +54,9 @@ namespace Luticate2.Utils.Business
         }
 
 
-
-
-        public virtual LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc)
+        public TId GetDboId(TDboRead obj)
         {
-            var res = CheckAdd(objs);
-            if (!res)
-            {
-                return res.To<T>();
-            }
-            return DataAccess.Add(res.Data, returnFunc);
+            return DataAccess.GetDboId(obj);
         }
 
         public virtual LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc)
@@ -100,26 +76,6 @@ namespace Luticate2.Utils.Business
             return newEntity.To<T>();
         }
 
-        public virtual LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs)
-        {
-            return Add(objs, reads => reads.Select(read => (TId)((dynamic)read).Id));
-        }
-
-        public virtual LuResult<TId> AddId(TDboCreate obj)
-        {
-            return Add(obj, read => (TId)((dynamic)read).Id);
-        }
-
-        public virtual LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> objs)
-        {
-            return Add(objs, reads => reads);
-        }
-
-        public virtual LuResult<TDboRead> AddDbo(TDboCreate obj)
-        {
-            return Add(obj, read => read);
-        }
-
 
 
 
@@ -129,16 +85,9 @@ namespace Luticate2.Utils.Business
         }
 
 
-        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
-            int page = 0, int perPage = int.MaxValue)
-        {
-            return DataAccess.GetMultiple(orderBy, filter, page, perPage);
-        }
-
-        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0,
-            int perPage = int.MaxValue)
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuPaginatedRequestDbo request)
         {
-            return GetMultiple(orderBy, new LuFilterDbo { Query = ""}, page, perPage);
+            return DataAccess.GetMultiple(request);
         }
 
 
@@ -167,16 +116,6 @@ namespace Luticate2.Utils.Business
             return editedEntity.To<T>();
         }
 
-        public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
-        {
-            return EditSingleById(id, update, read => (TId)((dynamic)read).Id);
-        }
-
-        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
-        {
-            return EditSingleById(id, update, read => read);
-        }
-
 
 
 
@@ -195,15 +134,5 @@ namespace Luticate2.Utils.Business
             }
             return res;
         }
-
-        public virtual LuResult<TId> DeleteSingleByIdId(TId id)
-        {
-            return DeleteSingleById(id, read => (TId)((dynamic)read).Id);
-        }
-
-        public virtual LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
-        {
-            return DeleteSingleById(id, read => read);
-        }
     }
 }

Luticate2.Utils/Business/LuNotificationsBusiness.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Linq;
 using Luticate2.Utils.Hubs;
+using Luticate2.Utils.Interfaces;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.AspNetCore.SignalR.Infrastructure;
 
 namespace Luticate2.Utils.Business
 {
-    public class LuNotificationsBusiness
+    public class LuNotificationsBusiness : ILuNotificationsBusiness
     {
         private readonly LuHubConnectionTracker _connectionTracker;
         private readonly IHubContext _hubContext;

Luticate2.Utils/Controllers/LuCrudController.cs

@@ -1,9 +1,8 @@
 using System.ComponentModel.DataAnnotations;
 using Luticate2.Utils.Dbo.Basic;
-using Luticate2.Utils.Dbo.Filter;
-using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Interfaces;
+using Luticate2.Utils.Utils;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Options;
 
@@ -33,7 +32,7 @@ namespace Luticate2.Utils.Controllers
         [Route("[controller]")]
         public virtual LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple([Required]LuPaginatedRequestDbo request)
         {
-            return Handle(Busines.GetMultiple(request.OrderBy, request.Filter, request.Page, request.PerPage));
+            return Handle(Busines.GetMultiple(request));
         }
 
         [HttpPost]

Luticate2.Utils/Controllers/LuFsFilesCrudController.cs

@@ -0,0 +1,59 @@
+using System.ComponentModel.DataAnnotations;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.FsFiles;
+using Luticate2.Utils.Dbo.PaginatedRequest;
+using Luticate2.Utils.Interfaces;
+using Luticate2.Utils.Utils;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+
+namespace Luticate2.Utils.Controllers
+{
+    public class LuFsFilesCrudController<TBusiness> : LuController
+        where TBusiness : ILuCrudInterface<LuFsFilesAddDbo, LuFsFilesDbo, LuFsFilesAddDbo, string>
+    {
+        private readonly TBusiness _business;
+
+        public LuFsFilesCrudController(IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo, TBusiness business) : base(luUtilsOptionsDbo)
+        {
+            _business = business;
+        }
+
+        [HttpPost]
+        [Route("[controller]")]
+        public LuApiWrapperDbo<LuFsFilesDbo> AddDbo([Required]IFormFile file, string path)
+        {
+            return Handle(_business.AddDbo(new LuFsFilesAddDbo
+            {
+                File = file.OpenReadStream(),
+                Path = string.IsNullOrEmpty(path) ? file.FileName : path
+            }));
+        }
+
+        [HttpGet]
+        [Route("[controller]")]
+        public virtual LuApiWrapperDbo<LuPaginatedDbo<LuFsFilesDbo>> GetMultiple([Required]LuPaginatedRequestDbo request)
+        {
+            return Handle(_business.GetMultiple(request));
+        }
+
+        [HttpPost]
+        [Route("[controller]/{id}")]
+        public virtual LuApiWrapperDbo<LuFsFilesDbo> EditSingleByIdDbo([Required]string id, IFormFile file, string path)
+        {
+            return Handle(_business.EditSingleByIdDbo(id, new LuFsFilesAddDbo
+            {
+                File = file?.OpenReadStream(),
+                Path = path
+            }));
+        }
+
+        [HttpDelete]
+        [Route("[controller]/{id}")]
+        public virtual LuApiWrapperDbo<LuFsFilesDbo> Delete([Required]string id)
+        {
+            return Handle(_business.DeleteSingleByIdDbo(id));
+        }
+    }
+}

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

@@ -9,6 +9,7 @@ using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Hubs;
+using Luticate2.Utils.Interfaces;
 using Luticate2.Utils.Middlewares;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
@@ -39,7 +40,7 @@ namespace Luticate2.Utils.Controllers
 
             services.AddScoped<LuEfTransactionScope>();
             services.AddSingleton<LuHubConnectionTracker>();
-            services.AddSingleton<LuNotificationsBusiness>();
+            services.AddSingleton<ILuNotificationsBusiness, LuNotificationsBusiness>();
             services.Configure(optionsDelegate);
             return services;
         }
@@ -100,6 +101,14 @@ namespace Luticate2.Utils.Controllers
             {
                 return 500;
             }
+            if (result.Status == LuStatus.FsError)
+            {
+                return 500;
+            }
+            if (result.Status == LuStatus.BackendError)
+            {
+                return 500;
+            }
             if (result.Status == LuStatus.InternalError)
             {
                 return 500;
@@ -133,6 +142,14 @@ namespace Luticate2.Utils.Controllers
             {
                 return "Internal Error";
             }
+            if (result.Status == LuStatus.FsError)
+            {
+                return "Internal Error";
+            }
+            if (result.Status == LuStatus.BackendError)
+            {
+                return "Internal Error";
+            }
             if (result.Status == LuStatus.InternalError)
             {
                 return "Internal Error";

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

@@ -5,6 +5,7 @@ using System.Linq.Expressions;
 using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 using Luticate2.Utils.Interfaces;
 using Luticate2.Utils.Utils;
@@ -91,6 +92,11 @@ namespace Luticate2.Utils.DataAccess
             return table;
         }
 
+        public TId GetDboId(TDboRead obj)
+        {
+            return GetIdFunc<TId>()(obj);
+        }
+
         protected virtual Func<TDboRead, T> GetIdFunc<T>()
         {
             return x => ((dynamic) x).Id;
@@ -160,22 +166,12 @@ namespace Luticate2.Utils.DataAccess
             return Add(objs, list => list.Select(func));
         }
 
-        public virtual LuResult<TId> AddId(TDboCreate obj)
-        {
-            return AddId(new List<TDboCreate> {obj}).To(list => list.First());
-        }
-
 
         public virtual LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj)
         {
             return Add(obj, read => read);
         }
 
-        public virtual LuResult<TDboRead> AddDbo(TDboCreate obj)
-        {
-            return AddDbo(new List<TDboCreate> {obj}).To(list => list.First());
-        }
-
 
 
 
@@ -304,15 +300,9 @@ namespace Luticate2.Utils.DataAccess
             });
         }
 
-        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
-            int page = 0, int perPage = int.MaxValue)
-        {
-            return GetMultiple(orderBy, (db, table) => GetFilterQuery(filter, db, table), page, perPage);
-        }
-
-        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue)
+        public virtual LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuPaginatedRequestDbo request)
         {
-            return GetMultiple(orderBy, GetGetQueryable, page, perPage);
+            return GetMultiple(request.OrderBy, (db, table) => GetFilterQuery(request.Filter, db, table), request.Page, request.PerPage);
         }
 
 
@@ -418,16 +408,6 @@ namespace Luticate2.Utils.DataAccess
             return GetSingleById(id).To(returnFunc);
         }
 
-        public virtual LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update)
-        {
-            return EditSingleById(id, update, GetIdFunc<TId>());
-        }
-
-        public virtual LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update)
-        {
-            return EditSingleById(id, update, read => read);
-        }
-
 
 
 
@@ -473,16 +453,5 @@ namespace Luticate2.Utils.DataAccess
             return Delete(GetExpression(new KeyValuePair<string, object>("id", guid)),
                 reads => returnFunc(reads.FirstOrDefault()));
         }
-
-        public virtual LuResult<TId> DeleteSingleByIdId(TId id)
-        {
-            var func = GetIdFunc<TId>();
-            return DeleteSingleById(id, func);
-        }
-
-        public virtual LuResult<TDboRead> DeleteSingleByIdDbo(TId id)
-        {
-            return DeleteSingleById(id, read => read);
-        }
     }
 }

Luticate2.Utils/DataAccess/LuFsFilesCrudDataAccess.cs

@@ -0,0 +1,180 @@
+using System;
+using System.IO;
+using System.Linq;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Filter;
+using Luticate2.Utils.Dbo.FsFiles;
+using Luticate2.Utils.Dbo.PaginatedRequest;
+using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Interfaces;
+using Luticate2.Utils.Utils;
+
+namespace Luticate2.Utils.DataAccess
+{
+    public abstract class LuFsFilesCrudDataAccess : ILuCrudInterface<LuFsFilesAddDbo, LuFsFilesDbo, LuFsFilesAddDbo, string>
+    {
+        public abstract string GetBasePath();
+
+        public string GetFullPath(string path)
+        {
+            return Path.Combine(GetBasePath(), path);
+        }
+
+        public bool CanCreate(string fullpath)
+        {
+            try
+            {
+                using (File.Create(fullpath))
+                {
+                }
+                File.Delete(fullpath);
+                return true;
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+        }
+
+        public static Func<FileInfo, object> GetOrderByFieldExpression(string fieldName)
+        {
+            if (fieldName == "path")
+            {
+                return x => x.Name.ToLower();
+            }
+            if (fieldName == "createdAt")
+            {
+                return x => x.LastWriteTime;
+            }
+            if (fieldName == "size")
+            {
+                return x => x.Length;
+            }
+            return null;
+        }
+
+        public static Func<FileInfo, bool> GetFilterExpression(LuFilterDbo filter)
+        {
+            if (filter == null)
+            {
+                return s => true;
+            }
+            return s => s.Name.ToLower().Contains(filter.Query.ToLower());
+        }
+
+        public virtual LuResult<T> HandleError<T>(Exception e)
+        {
+            return LuResult<T>.Error(LuStatus.FsError, e);
+        }
+
+        public string GetDboId(LuFsFilesDbo obj)
+        {
+            return obj.Path;
+        }
+
+        public LuResult<T> Add<T>(LuFsFilesAddDbo file, Func<LuFsFilesDbo, T> returnFunc)
+        {
+            var fullpath = GetFullPath(file.Path);
+            if (File.Exists(fullpath))
+            {
+                return LuResult<T>.Error(LuStatus.InputError, $"File: {file.Path}", "File already exist");
+            }
+            if (!CanCreate(fullpath))
+            {
+                return LuResult<T>.Error(LuStatus.FsError, $"File: {file.Path}", "File can not be created");
+            }
+            try
+            {
+                using (var fileStream = new FileStream(fullpath, FileMode.CreateNew, FileAccess.Write))
+                {
+                    file.File.CopyTo(fileStream);
+                }
+                return LuResult<T>.Ok(returnFunc(new FileInfo(fullpath).ToDbo()));
+            }
+            catch (Exception e)
+            {
+                return HandleError<T>(e);
+            }
+        }
+
+        public LuResult<LuFsFilesDbo> GetSingleById(string id)
+        {
+            var fullpath = GetFullPath(id);
+            if (!File.Exists(fullpath))
+            {
+                return LuResult<LuFsFilesDbo>.Error(LuStatus.NotFound, $"File {fullpath}", "File not found");
+            }
+            return LuResult<LuFsFilesDbo>.Ok(new FileInfo(fullpath).ToDbo());
+        }
+
+        public LuResult<LuPaginatedDbo<LuFsFilesDbo>> GetMultiple(LuPaginatedRequestDbo request)
+        {
+            try
+            {
+                var fullPath = GetBasePath();
+//                var fullPath = GetFullPath(request.Filter.GetFilterString("folder", ""));
+//                if (!Directory.Exists(fullPath))
+//                {
+//                    return LuResult<LuPaginatedDbo<LuFsFilesDbo>>.Error(LuStatus.NotFound, $"Folder: {fullPath}", "Folder not found");
+//                }
+                return LuResult<LuPaginatedDbo<LuFsFilesDbo>>.Ok(Directory.GetFiles(fullPath)
+                    .Select(s => new FileInfo(s))
+                    .Where(GetFilterExpression(request.Filter))
+                    .Paginate(request, GetOrderByFieldExpression)
+                    .Select(info => info.ToDbo()));
+            }
+            catch (Exception e)
+            {
+                return HandleError<LuPaginatedDbo<LuFsFilesDbo>>(e);
+            }
+        }
+
+        public LuResult<T> EditSingleById<T>(string id, LuFsFilesAddDbo update, Func<LuFsFilesDbo, T> returnFunc)
+        {
+            try
+            {
+                var get = GetSingleById(id);
+                if (!get)
+                {
+                    return get.To<T>();
+                }
+                var fullpath = GetFullPath(get.Data.Path);
+                if (update.Path != null)
+                {
+                    File.Move(fullpath, GetFullPath(update.Path));
+                    fullpath = GetFullPath(update.Path);
+                }
+                if (update.File != null)
+                {
+                    using (var fileStream = new FileStream(fullpath, FileMode.Open, FileAccess.Write))
+                    {
+                        update.File.CopyTo(fileStream);
+                    }
+                }
+                return LuResult<T>.Ok(returnFunc(new FileInfo(fullpath).ToDbo()));
+            }
+            catch (Exception e)
+            {
+                return HandleError<T>(e);
+            }
+        }
+
+        public LuResult<T> DeleteSingleById<T>(string id, Func<LuFsFilesDbo, T> returnFunc)
+        {
+            try
+            {
+                var get = GetSingleById(id);
+                if (get)
+                {
+                    var fullpath = GetFullPath(get.Data.Path);
+                    File.Delete(fullpath);
+                }
+                return get.To(returnFunc);
+            }
+            catch (Exception e)
+            {
+                return HandleError<T>(e);
+            }
+        }
+    }
+}

Luticate2.Utils/Dbo/Basic/LuPaginatedDbo.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace Luticate2.Utils.Dbo.Basic
 {
@@ -7,5 +9,23 @@ namespace Luticate2.Utils.Dbo.Basic
         public long Count { get; set; }
 
         public List<TDbo> Data { get; set; }
+
+        public LuPaginatedDbo<T> To<T>(Func<List<TDbo>, List<T>> convert)
+        {
+            return new LuPaginatedDbo<T>
+            {
+                Count = Count,
+                Data = convert(Data)
+            };
+        }
+
+        public LuPaginatedDbo<T> Select<T>(Func<TDbo, T> convert)
+        {
+            return new LuPaginatedDbo<T>
+            {
+                Count = Count,
+                Data = Data.Select(convert).ToList()
+            };
+        }
     }
 }

Luticate2.Utils/Dbo/FsFiles/LuFsFilesAddDbo.cs

@@ -0,0 +1,11 @@
+using System.IO;
+
+namespace Luticate2.Utils.Dbo.FsFiles
+{
+    public class LuFsFilesAddDbo
+    {
+        public string Path { get; set; }
+
+        public Stream File { get; set; }
+    }
+}

Luticate2.Utils/Dbo/FsFiles/LuFsFilesDbo.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Luticate2.Utils.Dbo.FsFiles
+{
+    public class LuFsFilesDbo
+    {
+        public string Id { get; set; }
+
+        public string Path { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+
+        public DateTime? UpdatedAt { get; set; }
+
+        public long Size { get; set; }
+    }
+}

Luticate2.Utils/Dbo/Result/LuStatus.cs

@@ -5,6 +5,8 @@
         Success,
         InputError,
         DbError,
+        FsError,
+        BackendError,
         PermissionError,
         LoginError,
         NotFound,

Luticate2.Utils/Interfaces/ILuCrudInterface.cs

@@ -1,8 +1,6 @@
 using System;
-using System.Collections.Generic;
 using Luticate2.Utils.Dbo.Basic;
-using Luticate2.Utils.Dbo.Filter;
-using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Luticate2.Utils.Dbo.Result;
 
 namespace Luticate2.Utils.Interfaces
@@ -12,46 +10,16 @@ namespace Luticate2.Utils.Interfaces
         where TDboRead : class
         where TDboUpdate : class
     {
-        LuResult<T> Add<T>(IEnumerable<TDboCreate> objs, Func<IEnumerable<TDboRead>, T> returnFunc);
+        TId GetDboId(TDboRead obj);
 
         LuResult<T> Add<T>(TDboCreate obj, Func<TDboRead, T> returnFunc);
 
-
-        LuResult<IEnumerable<TId>> AddId(IEnumerable<TDboCreate> objs);
-
-        LuResult<TId> AddId(TDboCreate obj);
-
-        LuResult<IEnumerable<TDboRead>> AddDbo(IEnumerable<TDboCreate> obj);
-
-        LuResult<TDboRead> AddDbo(TDboCreate obj);
-
-
-
-
         LuResult<TDboRead> GetSingleById(TId id);
 
-
-        LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
-            int page = 0, int perPage = int.MaxValue);
-
-        LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, int page = 0, int perPage = int.MaxValue);
-
-
-
+        LuResult<LuPaginatedDbo<TDboRead>> GetMultiple(LuPaginatedRequestDbo request);
 
         LuResult<T> EditSingleById<T>(TId id, TDboUpdate update, Func<TDboRead, T> returnFunc);
 
-        LuResult<TId> EditSingleByIdId(TId id, TDboUpdate update);
-
-        LuResult<TDboRead> EditSingleByIdDbo(TId id, TDboUpdate update);
-
-
-
-
         LuResult<T> DeleteSingleById<T>(TId id, Func<TDboRead, T> returnFunc);
-
-        LuResult<TId> DeleteSingleByIdId(TId id);
-
-        LuResult<TDboRead> DeleteSingleByIdDbo(TId id);
     }
 }

Luticate2.Utils/Interfaces/ILuNotificationsBusiness.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Luticate2.Utils.Interfaces
+{
+    public interface ILuNotificationsBusiness
+    {
+        void Notify(string eventName, string entityType, object oldEntity, object newEntity,
+            Func<string, bool> filter = null);
+
+        void NotifyCreate(string entityType, object newEntity, Func<string, bool> filter = null);
+
+        void NotifyUpdate(string entityType, object oldEntity, object newEntity,
+            Func<string, bool> filter = null);
+
+        void NotifyDelete(string entityType, object oldEntity, Func<string, bool> filter = null);
+    }
+}

Luticate2.Utils/Utils/LuCrudInterfaceExtensions.cs

@@ -0,0 +1,82 @@
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.Filter;
+using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.PaginatedRequest;
+using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Interfaces;
+
+namespace Luticate2.Utils.Utils
+{
+    public static class LuCrudInterfaceExtensions
+    {
+        public static LuResult<LuPaginatedDbo<TDboRead>> GetMultiple<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, LuOrderByDbo orderBy, LuFilterDbo filter,
+            int page = 0, int perPage = int.MaxValue)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.GetMultiple(new LuPaginatedRequestDbo
+            {
+                Filter = filter,
+                OrderBy = orderBy,
+                Page = page,
+                PerPage = perPage
+            });
+        }
+
+        public static LuResult<LuPaginatedDbo<TDboRead>> GetMultiple<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, LuOrderByDbo orderBy,
+            int page = 0, int perPage = int.MaxValue)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.GetMultiple(new LuPaginatedRequestDbo
+            {
+                Filter = null,
+                OrderBy = orderBy,
+                Page = page,
+                PerPage = perPage
+            });
+        }
+
+        public static LuResult<TDboRead> AddDbo<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, TDboCreate obj)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.Add(obj, o => o);
+        }
+
+        public static LuResult<TId> AddId<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, TDboCreate obj)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.Add(obj, crud.GetDboId);
+        }
+
+        public static LuResult<TDboRead> EditSingleByIdDbo<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, TId id, TDboUpdate update)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.EditSingleById(id, update, o => o);
+        }
+
+        public static LuResult<TId> EditSingleByIdId<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, TId id, TDboUpdate update)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.EditSingleById(id, update, crud.GetDboId);
+        }
+
+        public static LuResult<TDboRead> DeleteSingleByIdDbo<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, TId id)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.DeleteSingleById(id, o => o);
+        }
+
+        public static LuResult<TId> DeleteSingleByIdId<TDboCreate, TDboRead, TDboUpdate, TId>(
+            this ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId> crud, TId id)
+            where TDboCreate : class where TDboRead : class where TDboUpdate : class
+        {
+            return crud.DeleteSingleById(id, crud.GetDboId);
+        }
+    }
+}

Luticate2.Utils/Utils/LuExtensions.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.FsFiles;
+using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.PaginatedRequest;
+
+namespace Luticate2.Utils.Utils
+{
+    public static class LuExtensions
+    {
+        public static LuFsFilesDbo ToDbo(this FileInfo file)
+        {
+            if (file == null)
+            {
+                return null;
+            }
+            return new LuFsFilesDbo
+            {
+                Id = file.Name,
+                Path = file.Name,
+                CreatedAt = file.CreationTime.ToDbo(),
+                UpdatedAt = file.LastWriteTime.ToDbo(),
+                Size = file.Length
+            };
+        }
+
+        public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> list, LuOrderByDbo orderBy,
+            Func<string, Func<T, object>> getOrderByFieldExpression)
+        {
+            IOrderedEnumerable<T> ordered = null;
+            foreach (var field in orderBy.Fields)
+            {
+                var exp = getOrderByFieldExpression(field.Name);
+                if (ordered != null)
+                {
+                    ordered = field.Asc ? ordered.ThenBy(exp) : ordered.ThenByDescending(exp);
+                }
+                else
+                {
+                    ordered = field.Asc ? list.OrderBy(exp) : list.OrderByDescending(exp);
+                }
+            }
+            return ordered ?? list;
+        }
+
+        public static LuPaginatedDbo<T> Paginate<T>(this IEnumerable<T> list, LuPaginatedRequestDbo paginatedRequestDbo,
+            Func<string, Func<T, object>> getOrderByFieldExpression)
+        {
+            var ordered = list.OrderBy(paginatedRequestDbo.OrderBy, getOrderByFieldExpression).ToList();
+
+            return new LuPaginatedDbo<T>
+            {
+                Count = ordered.Count,
+                Data = ordered.Skip(paginatedRequestDbo.Page * paginatedRequestDbo.PerPage).Take(paginatedRequestDbo.PerPage).ToList()
+            };
+        }
+    }
+}

TestUtils/DataAccess/LuTmpFsFilesCrudDataAccess.cs

@@ -0,0 +1,19 @@
+using Luticate2.Utils.DataAccess;
+
+namespace TestUtils.DataAccess
+{
+    public class LuTmpFsFilesCrudDataAccess : LuFsFilesCrudDataAccess
+    {
+        private readonly string _basePath;
+
+        public LuTmpFsFilesCrudDataAccess(string basePath)
+        {
+            _basePath = basePath;
+        }
+
+        public override string GetBasePath()
+        {
+            return _basePath;
+        }
+    }
+}

TestUtils/DataAccess/LuUtilsPkBigSerialDataAccess.cs

@@ -37,6 +37,10 @@ namespace TestUtils.DataAccess
 
         protected override Expression<Func<pk_bigserial, bool>> GetFilterExpression(LuFilterDbo filter)
         {
+            if (filter == null)
+            {
+                return x => true;
+            }
             var query = filter.Query.ToLower();
             return model => model.some_text.ToLower().Contains(query) || model.some_int.ToString().Contains(query);
         }

TestUtils/DataAccess/LuUtilsPkGuidDataAccess.cs

@@ -64,6 +64,10 @@ namespace TestUtils.DataAccess
 
         protected override Expression<Func<pk_guid, bool>> GetFilterExpression(LuFilterDbo filter)
         {
+            if (filter == null)
+            {
+                return x => true;
+            }
             var someText = filter.GetFilterString("someText", null);
             var someInt = filter.GetFilterInt("someInt", null);
             return model => LuUtilsDbContext.lu_texts_match(filter.Query, model.some_text + " " + model.some_int.ToString())

TestUtils/EfCrudDataAccess/LuEfCreateDataAccessTest.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
 using TestUtils.DataAccess;
 using TestUtils.Dbo.FkPkGuid;
 using TestUtils.Dbo.PkBigSerial;

TestUtils/EfCrudDataAccess/LuEfDeleteDataAccessTest.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
 using TestUtils.DataAccess;
 using TestUtils.Dbo.PkBigSerial;
 using TestUtils.Dbo.PkGuid;

TestUtils/EfCrudDataAccess/LuEfReadDataAccessTest.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Luticate2.Utils.Dbo;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
 using TestUtils.DataAccess;
 using TestUtils.Dbo.PkBigSerial;
 using TestUtils.Dbo.PkGuid;

TestUtils/EfCrudDataAccess/LuEfTransactionScopeTest.cs

@@ -1,5 +1,6 @@
 using System;
 using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
 using Microsoft.Extensions.DependencyInjection;
 using TestUtils.DataAccess;
 using TestUtils.Dbo.PkGuid;
@@ -12,7 +13,7 @@ namespace TestUtils.EfCrudDataAccess
         [Fact]
         public void TestAddDboSingle1()
         {
-            var serviceProvider = Tests.BuildServiceProvider();
+            var serviceProvider = Tests.BuildRealDbServiceProvider();
             var service = serviceProvider.GetService<LuUtilsPkGuidDataAccess>();
             var transact = service.BeginTransaction(null);
             var res = service.AddDbo(new PkGuidAddDbo

TestUtils/EfCrudDataAccess/LuEfUpdateDataAccessTest.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
 using TestUtils.DataAccess;
 using TestUtils.Dbo.PkBigSerial;
 using TestUtils.Dbo.PkGuid;

TestUtils/EfCrudDataAccess/LuFsFilesCrudDataAccessTest.cs

@@ -0,0 +1,361 @@
+using System.Collections.Generic;
+using System.IO;
+using Luticate2.Utils.DataAccess;
+using Luticate2.Utils.Dbo.FsFiles;
+using Luticate2.Utils.Dbo.OrderBy;
+using Luticate2.Utils.Dbo.PaginatedRequest;
+using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
+using Xunit;
+
+namespace TestUtils.EfCrudDataAccess
+{
+    public class LuFsFilesCrudDataAccessTest
+    {
+        public static Stream GenerateStreamFromString(string s)
+        {
+            if (s == null)
+            {
+                return null;
+            }
+            var stream = new MemoryStream();
+            var writer = new StreamWriter(stream);
+            writer.Write(s);
+            writer.Flush();
+            stream.Position = 0;
+            return stream;
+        }
+
+        public static bool CheckFileContent(LuFsFilesCrudDataAccess access, string path, string content)
+        {
+            return File.ReadAllText(access.GetFullPath(path)) == content;
+        }
+
+        public static LuFsFilesDbo TestAdd(LuFsFilesCrudDataAccess access, string path, string content)
+        {
+            var res = access.AddDbo(new LuFsFilesAddDbo
+            {
+                File = GenerateStreamFromString(content),
+                Path = path
+            });
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal(path, res.Data.Path);
+            Assert.Equal(content.Length, res.Data.Size);
+            Assert.True(CheckFileContent(access, res.Data.Path, content));
+            return res.Data;
+        }
+
+        public static LuFsFilesDbo TestEdit(LuFsFilesCrudDataAccess access, string path, string content, string pathEdit, string contentEdit)
+        {
+            TestAdd(access, path, content);
+            TestGetSingleById(access, path, content);
+            var res = access.EditSingleByIdDbo(path, new LuFsFilesAddDbo
+            {
+                File = GenerateStreamFromString(contentEdit),
+                Path = pathEdit
+            });
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal(pathEdit ?? path, res.Data.Path);
+            Assert.Equal(contentEdit?.Length ?? content.Length, res.Data.Size);
+            Assert.True(CheckFileContent(access, res.Data.Path, contentEdit ?? content));
+            return res.Data;
+        }
+
+        public static LuFsFilesDbo TestGetSingleById(LuFsFilesCrudDataAccess access, string path, string content)
+        {
+            var res = access.GetSingleById(path);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal(path, res.Data.Path);
+            Assert.Equal(content.Length, res.Data.Size);
+            Assert.True(CheckFileContent(access, res.Data.Path, content));
+            return res.Data;
+        }
+
+        public static LuFsFilesDbo TestDeleteSingleById(LuFsFilesCrudDataAccess access, string path)
+        {
+            var del = access.DeleteSingleByIdDbo(path);
+            Assert.Equal(LuStatus.Success, del.Status);
+            Assert.Equal(path, del.Data.Path);
+
+            var get = access.GetSingleById(path);
+            Assert.Equal(LuStatus.NotFound, get.Status);
+
+            return del.Data;
+        }
+
+        public static void TestGetMultiple(LuFsFilesCrudDataAccess access, LuPaginatedRequestDbo request,
+            List<string> paths, List<string> contents,
+            List<int> gets, int count, bool add = true)
+        {
+            if (add)
+            {
+                for (var i = 0; i < paths.Count; ++i)
+                {
+                    TestAdd(access, paths[i], contents[i]);
+                    TestGetSingleById(access, paths[i], contents[i]);
+                }
+            }
+            var get = access.GetMultiple(request);
+            Assert.Equal(LuStatus.Success, get.Status);
+            Assert.Equal(count, get.Data.Count);
+            Assert.Equal(gets.Count, get.Data.Data.Count);
+            for (var i = 0; i < gets.Count; ++i)
+            {
+                Assert.Equal(paths[gets[i]], get.Data.Data[i].Path);
+                Assert.Equal(contents[gets[i]].Length, get.Data.Data[i].Size);
+                Assert.True(CheckFileContent(access, paths[gets[i]], contents[gets[i]]));
+            }
+        }
+
+        [Fact]
+        public void TestAdd1()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                TestAdd(access, path, content);
+                TestGetSingleById(access, path, content);
+            });
+        }
+
+        [Fact]
+        public void TestAdd2()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                TestAdd(access, path, content);
+                TestGetSingleById(access, path, content);
+
+                var res = access.AddDbo(new LuFsFilesAddDbo
+                {
+                    File = GenerateStreamFromString(content),
+                    Path = path
+                });
+                Assert.Equal(LuStatus.InputError, res.Status);
+            });
+        }
+
+        [Fact]
+        public void TestGetMutliple1()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var paths = new List<string> {"42.txt", "24.txt", "test"};
+                var contents = new List<string> {"txt.42", "txt.24", "test.test"};
+                var gets = new List<int>{1, 0, 2};
+                TestGetMultiple(access, new LuPaginatedRequestDbo
+                {
+                    Filter = null,
+                    OrderBy = new LuOrderByDbo
+                    {
+                        Fields = new List<LuOrderByFieldDbo>
+                        {
+                            new LuOrderByFieldDbo
+                            {
+                                Asc = true,
+                                Name = "path"
+                            }
+                        }
+                    },
+                    Page = 0,
+                    PerPage = int.MaxValue
+                }, paths, contents, gets, gets.Count);
+            });
+        }
+
+        [Fact]
+        public void TestGetMutliple2()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var paths = new List<string> {"42.txt", "24.txt", "test"};
+                var contents = new List<string> {"txt.42", "txt.24", "test.test"};
+                var gets = new List<int>{1, 0};
+                TestGetMultiple(access, new LuPaginatedRequestDbo
+                {
+                    Filter = null,
+                    OrderBy = new LuOrderByDbo
+                    {
+                        Fields = new List<LuOrderByFieldDbo>
+                        {
+                            new LuOrderByFieldDbo
+                            {
+                                Asc = true,
+                                Name = "path"
+                            }
+                        }
+                    },
+                    Page = 0,
+                    PerPage = 2
+                }, paths, contents, gets, paths.Count);
+            });
+        }
+
+        [Fact]
+        public void TestGetMutliple3()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var paths = new List<string> {"42.txt", "24.txt", "test"};
+                var contents = new List<string> {"txt.42", "txt.24", "test.test"};
+                var gets = new List<int>{2, 0, 1};
+                TestGetMultiple(access, new LuPaginatedRequestDbo
+                {
+                    Filter = null,
+                    OrderBy = new LuOrderByDbo
+                    {
+                        Fields = new List<LuOrderByFieldDbo>
+                        {
+                            new LuOrderByFieldDbo
+                            {
+                                Asc = false,
+                                Name = "path"
+                            }
+                        }
+                    },
+                    Page = 0,
+                    PerPage = int.MaxValue
+                }, paths, contents, gets, gets.Count);
+            });
+        }
+
+        [Fact]
+        public void TestDelete1()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                TestAdd(access, path, content);
+                TestGetSingleById(access, path, content);
+
+                TestDeleteSingleById(access, path);
+            });
+        }
+
+        [Fact]
+        public void TestDelete2()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                TestAdd(access, path, content);
+                TestGetSingleById(access, path, content);
+
+                TestDeleteSingleById(access, path);
+
+                var del = access.DeleteSingleByIdDbo(path);
+                Assert.Equal(LuStatus.NotFound, del.Status);
+            });
+        }
+
+        [Fact]
+        public void TestDelete3()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var paths = new List<string> {"42.txt", "24.txt", "test"};
+                var contents = new List<string> {"txt.42", "txt.24", "test.test"};
+                var gets = new List<int>{2, 0, 1};
+                TestGetMultiple(access, new LuPaginatedRequestDbo
+                {
+                    Filter = null,
+                    OrderBy = new LuOrderByDbo
+                    {
+                        Fields = new List<LuOrderByFieldDbo>
+                        {
+                            new LuOrderByFieldDbo
+                            {
+                                Asc = false,
+                                Name = "path"
+                            }
+                        }
+                    },
+                    Page = 0,
+                    PerPage = int.MaxValue
+                }, paths, contents, gets, gets.Count);
+
+                var path = paths[0];
+                TestDeleteSingleById(access, path);
+
+                var del = access.DeleteSingleByIdDbo(path);
+                Assert.Equal(LuStatus.NotFound, del.Status);
+
+                gets = new List<int>{2, 1};
+                TestGetMultiple(access, new LuPaginatedRequestDbo
+                {
+                    Filter = null,
+                    OrderBy = new LuOrderByDbo
+                    {
+                        Fields = new List<LuOrderByFieldDbo>
+                        {
+                            new LuOrderByFieldDbo
+                            {
+                                Asc = false,
+                                Name = "path"
+                            }
+                        }
+                    },
+                    Page = 0,
+                    PerPage = int.MaxValue
+                }, paths, contents, gets, gets.Count, false);
+            });
+        }
+
+        [Fact]
+        public void TestEdit1()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                var pathEdit = "4224.txt";
+                var contentEdit = "4224";
+                TestEdit(access, path, content, pathEdit, contentEdit);
+                TestGetSingleById(access, pathEdit, contentEdit);
+            });
+        }
+
+        [Fact]
+        public void TestEdit2()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                var contentEdit = "4224";
+                TestEdit(access, path, content, null, contentEdit);
+                TestGetSingleById(access, path, contentEdit);
+            });
+        }
+
+        [Fact]
+        public void TestEdit3()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                var pathEdit = "4224.txt";
+                TestEdit(access, path, content, pathEdit, null);
+                TestGetSingleById(access, pathEdit, content);
+            });
+        }
+
+        [Fact]
+        public void TestEdit4()
+        {
+            Tests.TestRealFs(access =>
+            {
+                var path = "42.txt";
+                var content = "42";
+                TestEdit(access, path, content, null, null);
+                TestGetSingleById(access, path, content);
+            });
+        }
+    }
+}

TestUtils/Tests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using Luticate2.Utils.DataAccess;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
@@ -8,24 +9,27 @@ namespace TestUtils
 {
     public class Tests
     {
-        public const string ConnectionString =
+        public const string RealDbConnectionString =
             "User ID=dev;Password=dev;Host=localhost;Port=5432;Database=luticate2_utils;Pooling=true;";
 
-        public static IServiceProvider BuildServiceProvider()
+        public const string RealFsDir =
+            "/tmp/luticate2/";
+
+        public static IServiceProvider BuildRealDbServiceProvider()
         {
             IServiceCollection serviceCollection = new ServiceCollection();
             serviceCollection.AddScoped<LuEfTransactionScope>();
             serviceCollection.AddTransient<LuUtilsPkBigSerialDataAccess>();
             serviceCollection.AddTransient<LuUtilsPkGuidDataAccess>();
             serviceCollection.AddTransient<LuUtilsFkPkGuidDataAccess>();
-            serviceCollection.AddDbContext<LuUtilsDbContext>(builder => builder.UseNpgsql(ConnectionString),
+            serviceCollection.AddDbContext<LuUtilsDbContext>(builder => builder.UseNpgsql(RealDbConnectionString),
                 ServiceLifetime.Transient);
             return serviceCollection.BuildServiceProvider();
         }
 
         protected static void _TestRealDb(Action<IServiceProvider> func)
         {
-            var serviceProvider = BuildServiceProvider();
+            var serviceProvider = BuildRealDbServiceProvider();
             var transactionScope = serviceProvider.GetService<LuEfTransactionScope>();
             transactionScope.BeginTransaction<LuUtilsDbContext>(null);
             try
@@ -53,5 +57,19 @@ namespace TestUtils
                 func(provider.GetService<TDataAccess>(), provider.GetService<TDataAccess2>());
             });
         }
+
+        public static void TestRealFs(Action<LuFsFilesCrudDataAccess> func)
+        {
+            var tmp = Path.Combine(RealFsDir, "RealFsDir-" + new Random().Next());
+            try
+            {
+                Directory.CreateDirectory(tmp);
+                func(new LuTmpFsFilesCrudDataAccess(tmp));
+            }
+            finally
+            {
+                Directory.Delete(tmp, true);
+            }
+        }
     }
 }

TestUtils/project.json

@@ -5,7 +5,7 @@
     },
     "dependencies": {
         "dotnet-test-xunit": "1.0.0-rc2-*",
-        "Luticate2.Utils": "0.3.*",
+        "Luticate2.Utils": "0.4.*",
         "Moq": "4.6.38-alpha",
         "System.Runtime.Serialization.Primitives": "4.1.1",
         "xunit": "2.1.0"

WebApiUtils/Business/UploadBusiness.cs

@@ -0,0 +1,14 @@
+using Luticate2.Utils.Business;
+using Luticate2.Utils.Dbo.FsFiles;
+using Luticate2.Utils.Interfaces;
+using WebApiUtils.DataAccess;
+
+namespace WebApiUtils.Business
+{
+    public class UploadBusiness : LuCrudBusiness<UploadDataAccess, LuFsFilesAddDbo, LuFsFilesDbo, LuFsFilesAddDbo, string>
+    {
+        public UploadBusiness(UploadDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness) : base(dataAccess, notificationsBusiness)
+        {
+        }
+    }
+}

WebApiUtils/Controllers/UploadController.cs

@@ -0,0 +1,14 @@
+using Luticate2.Utils.Controllers;
+using Luticate2.Utils.Dbo.Basic;
+using Microsoft.Extensions.Options;
+using WebApiUtils.Business;
+
+namespace WebApiUtils.Controllers
+{
+    public class UploadController : LuFsFilesCrudController<UploadBusiness>
+    {
+        public UploadController(IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo, UploadBusiness business) : base(luUtilsOptionsDbo, business)
+        {
+        }
+    }
+}

WebApiUtils/DataAccess/UploadDataAccess.cs

@@ -0,0 +1,12 @@
+using Luticate2.Utils.DataAccess;
+
+namespace WebApiUtils.DataAccess
+{
+    public class UploadDataAccess : LuFsFilesCrudDataAccess
+    {
+        public override string GetBasePath()
+        {
+            return "/tmp/luticate2/";
+        }
+    }
+}

WebApiUtils/Startup.cs

@@ -1,12 +1,16 @@
+using System.IO;
 using Luticate2.Utils.Controllers;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Logging;
 using TestUtils.DataAccess;
 using WebApiUtils.Business;
+using WebApiUtils.DataAccess;
 
 namespace WebApiUtils
 {
@@ -41,6 +45,8 @@ namespace WebApiUtils
 
             services.AddScoped<PkGuidBusiness>();
             services.AddScoped<LuUtilsPkGuidDataAccess>();
+            services.AddScoped<UploadBusiness>();
+            services.AddScoped<UploadDataAccess>();
             services.AddDbContext<LuUtilsDbContext>(options =>
             {
                 options.UseNpgsql(Configuration.GetConnectionString("default"));
@@ -60,9 +66,15 @@ namespace WebApiUtils
             loggerFactory.AddConsole(Configuration.GetSection("Logging"));
             loggerFactory.AddDebug();
 
-            app.UseApplicationInsightsRequestTelemetry();
-
-            app.UseApplicationInsightsExceptionTelemetry();
+//            app.UseApplicationInsightsRequestTelemetry();
+//
+//            app.UseApplicationInsightsExceptionTelemetry();
+            app.UseStaticFiles(new StaticFileOptions
+            {
+                ServeUnknownFileTypes = true,
+                FileProvider = new PhysicalFileProvider("/tmp/luticate2"),
+                RequestPath = new PathString("/upload")
+            });
 
             app.UseLuticateUtils();
 

WebApiUtils/project.json

@@ -13,6 +13,7 @@
         "Microsoft.Extensions.Logging.Console": "1.1.0",
         "Microsoft.Extensions.Logging.Debug": "1.1.0",
         "Microsoft.Extensions.Options.ConfigurationExtensions": "1.1.0",
+        "Microsoft.AspNetCore.StaticFiles": "1.1.0",
         "Microsoft.NETCore.App": {
             "version": "1.0.1",
             "type": "platform"