[WebApiUtils] Refractor; edit; delete

WebApiUtils/BusinessManager/SqlServerBasicManager.cs

+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Linq.Expressions;
+using iiie.Logs.DataAccess;
+using iiie.Logs.DBO;
+
+namespace iiie.WebApiUtils.BusinessManager
+{
+    /// <summary>
+    /// Helper for SQL Server data access
+    /// </summary>
+    public abstract class SqlServerBasicManager<TDbObject, TEntities, TThis>
+        where TDbObject : class
+        where TEntities : DbContext, new()
+        where TThis : SqlServerBasicManager<TDbObject, TEntities, TThis>, new()
+    {
+        /// <summary>
+        /// Return the table to be used
+        /// </summary>
+        /// <param name="db">The database</param>
+        /// <returns>The table instance</returns>
+        public abstract DbSet<TDbObject> GetTable(TEntities db);
+
+        /// <summary>
+        /// Return the database table to use
+        /// </summary>
+        /// <param name="db">The database instance</param>
+        /// <returns>The table</returns>
+        public static DbSet<TDbObject> GetTableStatic(TEntities db)
+        {
+            var type = new TThis();
+            return type.GetTable(db);
+        }
+
+        /// <summary>
+        /// Get a predicate form the given keys and values
+        /// </summary>
+        /// <param name="keys">The keys and values to select data</param>
+        /// <returns>The predicate</returns>
+        public static Expression<Func<TDbObject, bool>> GetExpression(params KeyValuePair<string, object>[] keys)
+        {
+            var param = Expression.Parameter(typeof(TDbObject), "x");
+            Expression totalExp = null;
+            foreach (var pair in keys)
+            {
+                var equalExp = Expression.Equal(Expression.Property(param, pair.Key), Expression.Constant(pair.Value));
+                totalExp = totalExp == null ? equalExp : Expression.And(equalExp, totalExp);
+            }
+            return Expression.Lambda<Func<TDbObject, bool>>(totalExp, param);
+        }
+
+        /// <summary>
+        /// Execute SQL quries in try catch
+        /// </summary>
+        /// <param name="func">The queries to be performed</param>
+        /// <returns>The result or an error</returns>
+        public static OpResult<U> Execute<U>(Func<TEntities, DbSet<TDbObject>, OpResult<U>> func)
+        {
+            try
+            {
+                using (var db = new TEntities())
+                {
+                    var table = GetTableStatic(db);
+                    return func(db, table);
+                }
+            }
+            catch (Exception e)
+            {
+                return Logger.Error<U>(ResultStatus.DBError, e);
+            }
+        }
+    }
+}

WebApiUtils/BusinessManager/SqlServerManager.cs

 using System.Linq.Expressions;
 using iiie.Logs.DataAccess;
 using iiie.Logs.DBO;
-using System.Linq.Dynamic;
 
 namespace iiie.WebApiUtils.BusinessManager
 {
     /// <summary>
     /// Helper for SQL Server data access
     /// </summary>
-    public abstract class SqlServerManager<TDbObject, TDbo, TEntities, TThis>
+    public abstract class SqlServerManager<TDbObject, TDboGet, TDboAdd, TDboEdit, TEntities, TThis>
+        : SqlServerBasicManager<TDbObject, TEntities, TThis>
         where TDbObject : class
         where TEntities : DbContext, new()
-        where TThis : SqlServerManager<TDbObject, TDbo, TEntities, TThis>,  new()
+        where TThis : SqlServerManager<TDbObject, TDboGet, TDboAdd, TDboEdit, TEntities, TThis>, new()
     {
-        private class DbObjectId
-        {
-            public long id { get; set; }
-        }
 
         /// <summary>
-        /// Return the table to be used
+        /// Convert a DB object to DBO
         /// </summary>
-        /// <param name="db">The database</param>
-        /// <returns>The table instance</returns>
-        public abstract DbSet<TDbObject> GetTable(TEntities db);
-
-        public abstract TDbo DbToDbo(TDbObject obj);
+        /// <param name="obj">The object to be converted</param>
+        /// <returns>The DBO</returns>
+        public abstract TDboGet DbToDboGet(TDbObject obj);
 
-        public abstract TDbObject DboToDb(TDbo obj);
+        /// <summary>
+        /// Convert a DBO to DB object
+        /// </summary>
+        /// <param name="obj">The object to be converted</param>
+        /// <returns>The DB object</returns>
+        public abstract TDbObject DboAddToDb(TDboAdd obj);
 
         /// <summary>
-        /// Return the database table to use
+        /// Convert a DBO to DB object
         /// </summary>
-        /// <param name="db">The database instance</param>
-        /// <returns>The table</returns>
-        public static DbSet<TDbObject> GetTableStatic(TEntities db)
-        {
-            var type = new TThis();
-            return type.GetTable(db);
-        }
+        /// <param name="obj">The object to be converted</param>
+        /// <param name="edit">The object beeing edited</param>
+        /// <returns>The DB object</returns>
+        public abstract TDbObject DboEditToDb(TDboEdit obj, TDbObject edit);
 
         /// <summary>
         /// Helper to convert DB object to DBO
         /// </summary>
         /// <param name="res">The result to convert</param>
         /// <returns>The DBO object</returns>
-        public static OpResult<TDbo> DbToDboStatic(OpResult<TDbObject> res)
+        public static TDboGet DbToDboGetStatic(TDbObject res)
         {
-            if (!res)
-                return OpResult<TDbo>.Error(res);
             var obj = new TThis();
-            return OpResult<TDbo>.Ok(obj.DbToDbo(res.Data));
+            return obj.DbToDboGet(res);
         }
         
         /// <summary>
         /// </summary>
         /// <param name="res">The result to convert</param>
         /// <returns>The DB object</returns>
-        public static OpResult<TDbObject> DboToDbStatic(OpResult<TDbo> res)
+        public static TDbObject DboAddToDbStatic(TDboAdd res)
         {
-            if (!res)
-                return OpResult<TDbObject>.Error(res);
             var obj = new TThis();
-            return OpResult<TDbObject>.Ok(obj.DboToDb(res.Data));
+            return obj.DboAddToDb(res);
         }
 
-        /// <summary>
-        /// Helper to convert DB object to DBO
-        /// </summary>
-        /// <param name="res">The result to convert</param>
-        /// <returns>The DBO object</returns>
-        public static TDbo DbToDboStatic(TDbObject res)
-        {
-            var obj = new TThis();
-            return obj.DbToDbo(res);
-        }
-        
         /// <summary>
         /// Helper to convert DBO object to DB
         /// </summary>
         /// <param name="res">The result to convert</param>
+        /// <param name="edit">The object beeing edited</param>
         /// <returns>The DB object</returns>
-        public static TDbObject DboToDbStatic(TDbo res)
+        public static TDbObject DboEditToDbStatic(TDboEdit res, TDbObject edit)
         {
             var obj = new TThis();
-            return obj.DboToDb(res);
+            return obj.DboEditToDb(res, edit);
         }
 
         /// <summary>
-        /// Execute SQL quries in try catch
+        /// Get a single DB object matching the predicate
         /// </summary>
-        /// <param name="func">The queries to be performed</param>
-        /// <returns>The result or an error</returns>
-        public static OpResult<U> Execute<U>(Func<TEntities, DbSet<TDbObject>, OpResult<U>> func)
+        /// <param name="table">The table to search in</param>
+        /// <param name="predicate">The predicate</param>
+        /// <returns>The object that match</returns>
+        public static OpResult<TDbObject> GetSingleDbObject(DbSet<TDbObject> table, Expression<Func<TDbObject, bool>> predicate)
         {
-            try
+            var o = table.FirstOrDefault(predicate);
+            if (o == null)
             {
-                using (var db = new TEntities())
-                {
-                    var table = GetTableStatic(db);
-                    return func(db, table);
-                }
-            }
-            catch (Exception e)
-            {
-                return Logger.Error<U>(ResultStatus.DBError, e);
+                return OpResult<TDbObject>.Error(ResultStatus.NotFound, typeof(TThis).Name + ": Value not found", "");
             }
+            return OpResult<TDbObject>.Ok(o);
         }
 
         /// <summary>
-        /// Get a single DB object matching the predicate
+        /// Get a single DBO matching the predicate
         /// </summary>
         /// <param name="predicate">The predicate</param>
         /// <returns>The object that match, or null</returns>
-        public static OpResult<TDbObject> GetSingle(Expression<Func<TDbObject, bool>> predicate)
+        public static OpResult<TDboGet> GetSingle(Expression<Func<TDbObject, bool>> predicate)
         {
             return Execute((db, table) =>
             {
-                var o = table.FirstOrDefault(predicate);
-                if (o == null)
-                {
-                    return OpResult<TDbObject>.Error(ResultStatus.NotFound, typeof(TThis).Name + ": Value not found", "");
-                }
-                return OpResult<TDbObject>.Ok(o);
-
+                var obj = GetSingleDbObject(table, predicate);
+                if (!obj)
+                    return obj.To<TDboGet>();
+                return OpResult<TDboGet>.Ok(DbToDboGetStatic(obj.Data));
             });
         }
 
         /// <summary>
-        /// Get a single DBO matching the predicate
+        /// Get an object by its primary key(s)
         /// </summary>
-        /// <param name="predicate">The predicate</param>
-        /// <returns>The object that match, or null</returns>
-        public static OpResult<TDbo> GetSingleDbo(Expression<Func<TDbObject, bool>> predicate)
+        /// <param name="keys">The key names and values</param>
+        /// <returns>The object</returns>
+        public static OpResult<TDboGet> GetSingleByKeys(params KeyValuePair<string, object>[] keys)
         {
-            return DbToDboStatic(GetSingle(predicate));
+            return GetSingle(GetExpression(keys));
+        }
+
+        /// <summary>
+        /// Get an object by its id
+        /// </summary>
+        /// <param name="id">The id of the object</param>
+        /// <returns>The object</returns>
+        public static OpResult<TDboGet> GetSingleById(long id)
+        {
+            return GetSingleByKeys(new KeyValuePair<string, object>("id", id));
         }
 
         /// <summary>
         /// Get all DB object matching the predicate
         /// </summary>
         /// <param name="predicate">The predicate</param>
+        /// <param name="orderBy">The order by function</param>
+        /// <param name="page">The page numeber (0 based)</param>
+        /// <param name="perPage">The maximum number of items par page</param>
         /// <returns>All matching objects</returns>
-        public static OpResult<IEnumerable<TDbObject>> GetMultiple(Expression<Func<TDbObject, bool>> predicate)
+        public static OpResult<IEnumerable<TDboGet>> GetMultiple<TKey>(Expression<Func<TDbObject, bool>> predicate,
+            Expression<Func<TDbObject, TKey>> orderBy, int page = 0,int perPage = Int32.MaxValue)
         {
-            return Execute((db, table) => OpResult<IEnumerable<TDbObject>>.Ok(table.Where(predicate).ToList()));
+            return Execute((db, table) =>
+            {
+                var results = table.OrderBy(orderBy).Where(predicate).Skip(page * perPage).Take(perPage).ToList();
+                return OpResult<IEnumerable<TDboGet>>.Ok(results.Select(DbToDboGetStatic));
+            });
         }
 
         /// <summary>
-        /// Get all DBO matching the predicate
+        /// Get all DB object matching the predicate built from keys
         /// </summary>
-        /// <typeparam name="TDbo">The DBO type</typeparam>
-        /// <param name="predicate">The predicate</param>
+        /// <param name="page">The page numeber (0 based)</param>
+        /// <param name="perPage">The maximum number of items par page</param>
+        /// <param name="orderBy">The order by function</param>
+        /// <param name="keys">The key names and values</param>
         /// <returns>All matching objects</returns>
-        public static OpResult<IEnumerable<TDbo>> GetMultipleDbo(Expression<Func<TDbObject, bool>> predicate)
+        public static OpResult<IEnumerable<TDboGet>> GetMultipleByKeys<TKey>(Expression<Func<TDbObject, TKey>> orderBy,
+            int page = 0, int perPage = Int32.MaxValue, params KeyValuePair<string, object>[] keys)
         {
-            var res = GetMultiple(predicate);
-            if (!res)
-                return OpResult<IEnumerable<TDbo>>.Error(res);
-            var dbo = res.Data.Select(DbToDboStatic);
-            return OpResult<IEnumerable<TDbo>>.Ok(dbo);
+            return GetMultiple(GetExpression(keys), orderBy, page, perPage);
         }
 
         /// <summary>
         /// </summary>
         /// <param name="obj">The object to be added</param>
         /// <returns>Always true or an OpResult error</returns>
-        public static OpResult<bool> Add(TDbObject obj)
+        public static OpResult<bool> Add(TDboAdd obj)
         {
             return Execute((db, table) =>
             {
-                table.Add(obj);
+                table.Add(DboAddToDbStatic(obj));
                 db.SaveChanges();
                 return OpResult<bool>.Ok(true);
             });
         }
 
         /// <summary>
-        /// Add an entry in the database
+        /// Edit an entry in the database
         /// </summary>
-        /// <param name="obj"></param>
+        /// <param name="obj">The object to be added</param>
+        /// <param name="predicate">The predicate to be used to select data</param>
         /// <returns>Always true or an OpResult error</returns>
-        public static OpResult<bool> AddDbo(TDbo obj)
+        public static OpResult<bool> Edit(TDboEdit obj, Expression<Func<TDbObject, bool>> predicate)
         {
-            return Add(DboToDbStatic(obj));
+            return Execute((db, table) =>
+            {
+                var edit = GetSingleDbObject(table, predicate);
+                if (!edit)
+                    return edit.To<bool>();
+                var res = DboEditToDbStatic(obj, edit.Data);
+                db.Entry(edit.Data).CurrentValues.SetValues(res);
+                db.SaveChanges();
+                return OpResult<bool>.Ok(true);
+            });
         }
 
         /// <summary>
-        /// Get an object by its primary key(s)
+        /// Edit an entry in the database
         /// </summary>
-        /// <param name="pairs">The key names and values</param>
-        /// <returns>The object</returns>
-        public static OpResult<TDbObject> GetByPrimary(params KeyValuePair<string, object>[] pairs)
+        /// <param name="obj">The object to be added</param>
+        /// <param name="keys">The keys to be used to select data</param>
+        /// <returns>Always true or an OpResult error</returns>
+        public static OpResult<bool> Edit(TDboEdit obj, params KeyValuePair<string, object>[] keys)
+        {
+            return Edit(obj, GetExpression(keys));
+        }
+
+        /// <summary>
+        /// Edit an entry in the database
+        /// </summary>
+        /// <param name="obj">The object to be added</param>
+        /// <param name="id">The id to be edited</param>
+        /// <returns>Always true or an OpResult error</returns>
+        public static OpResult<bool> EditById(TDboEdit obj, long id)
         {
-            var param = Expression.Parameter(typeof(TDbObject), "x");
-            Expression totalExp = null;
-            foreach (var pair in pairs)
+            return Edit(obj, new KeyValuePair<string, object>("id", id));
+        }
+
+        /// <summary>
+        /// Delete an entry in the database
+        /// </summary>
+        /// <param name="predicate">The predicate to be used to delete data</param>
+        /// <returns>Always true or an OpResult error</returns>
+        public static OpResult<bool> Delete(Expression<Func<TDbObject, bool>> predicate)
+        {
+            return Execute((db, table) =>
             {
-                var equalExp = Expression.Equal(Expression.Property(param, pair.Key), Expression.Constant(pair.Value));
-                totalExp = totalExp == null ? equalExp : Expression.And(equalExp, totalExp);
-            }
-            var lambda = Expression.Lambda<Func<TDbObject, bool>>(totalExp, param);
-            return GetSingle(lambda);
+                var del = GetSingleDbObject(table, predicate);
+                if (!del)
+                    return del.To<bool>();
+                table.Remove(del.Data);
+                db.SaveChanges();
+                return OpResult<bool>.Ok(true);
+            });
         }
 
         /// <summary>
-        /// Get an object by its id
+        /// Delete an entry in the database
         /// </summary>
-        /// <param name="id">The id of the object</param>
-        /// <returns>The object</returns>
-        public static OpResult<TDbObject> GetById(long id)
+        /// <param name="keys">The keys to be used to delete data</param>
+        /// <returns>Always true or an OpResult error</returns>
+        public static OpResult<bool> Delete(params KeyValuePair<string, object>[] keys)
         {
-            return GetByPrimary(new KeyValuePair<string, object>("id", id));
+            return Delete(GetExpression(keys));
         }
 
         /// <summary>
-        /// Get an object by its id
+        /// Delete an entry in the database
         /// </summary>
-        /// <param name="id">The id of the object</param>
-        /// <returns>The object</returns>
-        public static OpResult<TDbo> GetByIdDbo(long id)
+        /// <param name="id">The id to be deleted</param>
+        /// <returns>Always true or an OpResult error</returns>
+        public static OpResult<bool> DeleteById(long id)
         {
-            return DbToDboStatic(GetById(id));
+            return Delete(new KeyValuePair<string, object>("id", id));
         }
     }
 }

WebApiUtils/WebApiUtils.csproj

       <Private>True</Private>
     </Reference>
     <Reference Include="Logs, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\packages\Logs.dll.1.2.1\lib\net45\Logs.dll</HintPath>
+      <HintPath>..\packages\Logs.dll.1.2.2\lib\net45\Logs.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="Microsoft.Practices.EnterpriseLibrary.Common, Version=6.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
     <Compile Include="BusinessManager\BMRHandler.cs" />
     <Compile Include="BusinessManager\CheckModelForNullAttribute.cs" />
     <Compile Include="BusinessManager\ExceptionLoggerAttribute.cs" />
+    <Compile Include="BusinessManager\SqlServerBasicManager.cs" />
     <Compile Include="BusinessManager\SqlServerManager.cs" />
     <Compile Include="BusinessManager\ValidateModelStateAttribute.cs" />
     <Compile Include="BusinessManager\WebApiUtils.cs" />

WebApiUtils/packages.config

   <package id="EnterpriseLibrary.Logging" version="6.0.1304.0" targetFramework="net45" />
   <package id="EnterpriseLibrary.Logging.Database" version="6.0.1304.0" targetFramework="net45" />
   <package id="EntityFramework" version="6.1.3" targetFramework="net45" />
-  <package id="Logs.dll" version="1.2.1" targetFramework="net45" />
+  <package id="Logs.dll" version="1.2.2" targetFramework="net45" />
   <package id="Microsoft.AspNet.WebApi.Client" version="5.2.3" targetFramework="net45" />
   <package id="Microsoft.AspNet.WebApi.Core" version="5.2.3" targetFramework="net45" />
   <package id="Microsoft.AspNet.WebApi.WebHost" version="5.2.3" targetFramework="net45" />