began Auth

.idea/.idea.luticate2/riderModule.iml

@@ -4,14 +4,20 @@
     <content url="file://$MODULE_DIR$/../..">
       <sourceFolder url="file://$MODULE_DIR$/../../Luticate2.Auth" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/../../Luticate2.Utils" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/../../TestAuth" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/../../TestUtils" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/../../WebApiAuth" isTestSource="false" />
       <sourceFolder url="file://$MODULE_DIR$/../../WebApiUtils" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/../../Luticate2.Auth/bin" />
       <excludeFolder url="file://$MODULE_DIR$/../../Luticate2.Auth/obj" />
       <excludeFolder url="file://$MODULE_DIR$/../../Luticate2.Utils/bin" />
       <excludeFolder url="file://$MODULE_DIR$/../../Luticate2.Utils/obj" />
+      <excludeFolder url="file://$MODULE_DIR$/../../TestAuth/bin" />
+      <excludeFolder url="file://$MODULE_DIR$/../../TestAuth/obj" />
       <excludeFolder url="file://$MODULE_DIR$/../../TestUtils/bin" />
       <excludeFolder url="file://$MODULE_DIR$/../../TestUtils/obj" />
+      <excludeFolder url="file://$MODULE_DIR$/../../WebApiAuth/bin" />
+      <excludeFolder url="file://$MODULE_DIR$/../../WebApiAuth/obj" />
       <excludeFolder url="file://$MODULE_DIR$/../../WebApiUtils/bin" />
       <excludeFolder url="file://$MODULE_DIR$/../../WebApiUtils/obj" />
       <excludeFolder url="file://$MODULE_DIR$/../../packages" />

Luticate2.Auth/Attributes/EntityAccessors/LuAttrArgumentAccessor.cs

@@ -0,0 +1,34 @@
+using System.Reflection;
+using Luticate2.Auth.Interfaces.Permissions;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Luticate2.Auth.Attributes.EntityAccessors
+{
+    public class LuAttrArgumentAccessor : ILuAttrEntityAccessor
+    {
+        public object GetEntity(ActionExecutingContext context, object id)
+        {
+            var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
+            if (actionDescriptor != null)
+            {
+                var parameters = actionDescriptor.MethodInfo.GetParameters();
+                foreach (var parameter in parameters)
+                {
+                    var attributes = parameter.GetCustomAttributes<LuPermissionArgAttribute>();
+                    foreach (var attribute in attributes)
+                    {
+                        if (attribute.Id == id)
+                        {
+                            if (context.ActionArguments.ContainsKey(parameter.Name))
+                            {
+                                return context.ActionArguments[parameter.Name];
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+    }
+}

Luticate2.Auth/Attributes/EntityAccessors/LuAttrLoggedUserAccessor.cs

@@ -0,0 +1,21 @@
+using Luticate2.Auth.Interfaces.Permissions;
+using Luticate2.Auth.Interfaces.Users;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Luticate2.Auth.Attributes.EntityAccessors
+{
+    public class LuAttrLoggedUserAccessor : ILuAttrEntityAccessor
+    {
+        private readonly ILuLoggedUserAccessor _loggedUserAccessor;
+
+        public LuAttrLoggedUserAccessor(ILuLoggedUserAccessor loggedUserAccessor)
+        {
+            _loggedUserAccessor = loggedUserAccessor;
+        }
+
+        public object GetEntity(ActionExecutingContext context, object id)
+        {
+            return _loggedUserAccessor.GetLoggedUser();
+        }
+    }
+}

Luticate2.Auth/Attributes/LuPermissionArgAttribute.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Luticate2.Auth.Attributes
+{
+    [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = true, Inherited = true)]
+    public class LuPermissionArgAttribute : Attribute
+    {
+        public object Id { get; set; }
+    }
+}

Luticate2.Auth/Attributes/LuPermissionAttribute.cs

@@ -0,0 +1,43 @@
+using System;
+using Luticate2.Auth.Attributes.EntityAccessors;
+using Luticate2.Auth.Dbo.Permissions;
+
+namespace Luticate2.Auth.Attributes
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
+    public class LuPermissionAttribute : Attribute
+    {
+        public string PermissionName { get; protected set; }
+
+        public string SrcEntityType { get; protected set; }
+
+        public Type SrcEntityAccessor { get; protected set; }
+
+        public string DstEntityType { get; protected set; }
+
+        public Type DstEntityAccessor { get; protected set; }
+
+        public object Id { get; protected set; }
+
+        public LuPermissionAttribute(string permissionName, string srcEntityType, Type srcEntityAccessor,
+            string dstEntityType, Type dstEntityAccessor, object id = null)
+        {
+            PermissionName = permissionName;
+            SrcEntityType = srcEntityType;
+            SrcEntityAccessor = srcEntityAccessor;
+            DstEntityType = dstEntityType;
+            DstEntityAccessor = dstEntityAccessor;
+            Id = id;
+        }
+
+        public LuPermissionAttribute(string permissionName, string dstEntityType, Type dstEntityAccessor, object id = null)
+            : this(permissionName, LuEntityTypes.LuUsers, typeof(LuAttrLoggedUserAccessor), dstEntityType, dstEntityAccessor, id)
+        {
+        }
+
+        public LuPermissionAttribute(string permissionName, string dstEntityType, object id = null)
+            : this(permissionName, dstEntityType, typeof(LuAttrArgumentAccessor), id)
+        {
+        }
+    }
+}

Luticate2.Auth/Business/LuBusinessExtensions.cs

@@ -0,0 +1,6 @@
+namespace Luticate2.Auth.Business
+{
+    public static class LuBusinessExtensions
+    {
+    }
+}

Luticate2.Auth/Business/LuGroupsBusiness.cs

@@ -1,20 +1,16 @@
 using Luticate2.Auth.DataAccess;
+using Luticate2.Auth.Dbo.Groups;
+using Luticate2.Auth.Interfaces.Groups;
 using Luticate2.Utils.Business;
+using Luticate2.Utils.Interfaces;
 
 namespace Luticate2.Auth.Business
 {
-    public class LuGroupsBusiness : LuBusiness
+    public class LuGroupsBusiness : LuCrudBusiness<LuGroupsDataAccess, LuGroupsAddDbo, LuGroupsDbo, LuGroupsAddDbo, string>,
+        ILuGroupsBusiness
     {
-        private readonly LuGroupsDataAccess _luGroupsDataAccess;
-
-        public LuGroupsBusiness(LuGroupsDataAccess dataAccess)
-        {
-            _luGroupsDataAccess = dataAccess;
-        }
-
-        public string Get()
+        public LuGroupsBusiness(LuGroupsDataAccess dataAccess, ILuNotificationsBusiness notificationsBusiness) : base(dataAccess, notificationsBusiness)
         {
-            return _luGroupsDataAccess.Get();
         }
     }
 }

Luticate2.Auth/Business/LuPermissionsBusiness.cs

@@ -0,0 +1,21 @@
+using System;
+using Luticate2.Auth.Interfaces.Permissions;
+using Luticate2.Utils.Dbo.Result;
+
+namespace Luticate2.Auth.Business
+{
+    public class LuPermissionsBusiness : ILuPermissionsBusiness
+    {
+        public LuResult<bool> GetPermissionValue(string permissionName, string srcEntityType, object srcEntity,
+            string dstEntityType, object dstEntity)
+        {
+            return LuResult<bool>.Ok(true);
+        }
+
+        public LuResult<bool> GetPermissionEffectiveValue(string permissionName, string srcEntityType, object srcEntity,
+            string dstEntityType, object dstEntity)
+        {
+            return LuResult<bool>.Ok(true);
+        }
+    }
+}

Luticate2.Auth/Business/LuUsersBusiness.cs

@@ -0,0 +1,39 @@
+using System;
+using Luticate2.Auth.Dbo.Users;
+using Luticate2.Auth.Interfaces.Users;
+using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
+
+namespace Luticate2.Auth.Business
+{
+    public class LuUsersBusiness : ILuUsersBusiness
+    {
+        public LuResult<UsersToken> GetToken(string token)
+        {
+            var id = Guid.NewGuid().ToDbo();
+            return LuResult<UsersToken>.Ok(new UsersToken
+            {
+                UserId = id
+            });//TODO
+        }
+
+        public LuResult<string> RegisterToken(UsersToken token)
+        {
+            return LuResult<string>.Ok("token");//TODO
+        }
+
+        public LuResult<UsersToken> UnRegisterToken(string token)
+        {
+            return LuResult<UsersToken>.Ok(new UsersToken());//TODO
+        }
+
+        public LuResult<UsersDbo> GetSingleById(string id)
+        {
+            return LuResult<UsersDbo>.Ok(new UsersDbo
+            {
+                Id = id,
+                Username = "user-" + id.Split('-')[0]
+            });//TODO
+        }
+    }
+}

Luticate2.Auth/Controllers/LuAuthController.cs

@@ -0,0 +1,16 @@
+using Luticate2.Auth.Dbo.Users;
+using Luticate2.Utils.Controllers;
+using Luticate2.Utils.Dbo.Basic;
+using Microsoft.Extensions.Options;
+
+namespace Luticate2.Auth.Controllers
+{
+    public class LuAuthController : LuController
+    {
+//        protected UsersDbo LoggedUser => LuItems["loggedUser"] as UsersDbo;
+
+        public LuAuthController(IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(luUtilsOptionsDbo)
+        {
+        }
+    }
+}

Luticate2.Auth/Controllers/LuAuthCrudController.cs

@@ -0,0 +1,54 @@
+using System.ComponentModel.DataAnnotations;
+using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.PaginatedRequest;
+using Luticate2.Utils.Interfaces;
+using Luticate2.Utils.Utils;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+
+namespace Luticate2.Auth.Controllers
+{
+    public abstract class LuAuthCrudController<TBusiness, TDboCreate, TDboRead, TDboUpdate, TId> : LuAuthController
+        where TDboCreate : class
+        where TDboRead : class
+        where TDboUpdate : class
+        where TBusiness : ILuCrudInterface<TDboCreate, TDboRead, TDboUpdate, TId>
+    {
+        protected readonly TBusiness Busines;
+
+        protected LuAuthCrudController(TBusiness busines, IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(luUtilsOptionsDbo)
+        {
+            Busines = busines;
+        }
+
+        [HttpGet("[controller]/{id}")]
+        public virtual LuApiWrapperDbo<TDboRead> GetSingleById([Required]TId id)
+        {
+            return Handle(Busines.GetSingleById(id));
+        }
+
+        [HttpGet("[controller]")]
+        public virtual LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple([Required]LuPaginatedRequestDbo request)
+        {
+            return Handle(Busines.GetMultiple(request));
+        }
+
+        [HttpPost("[controller]")]
+        public virtual LuApiWrapperDbo<TDboRead> AddDbo([FromBody][Required]TDboCreate data)
+        {
+            return Handle(Busines.AddDbo(data));
+        }
+
+        [HttpPost("[controller]/{id}")]
+        public virtual LuApiWrapperDbo<TDboRead> EditSingleByIdDbo([Required]TId id, [FromBody][Required]TDboUpdate data)
+        {
+            return Handle(Busines.EditSingleByIdDbo(id, data));
+        }
+
+        [HttpDelete("[controller]/{id}")]
+        public virtual LuApiWrapperDbo<TDboRead> Delete([Required]TId id)
+        {
+            return Handle(Busines.DeleteSingleByIdDbo(id));
+        }
+    }
+}

Luticate2.Auth/Controllers/LuAuthExtensions.cs

@@ -1,28 +1,56 @@
 using System;
+using Luticate2.Auth.Attributes.EntityAccessors;
 using Luticate2.Auth.Business;
 using Luticate2.Auth.DataAccess;
+using Luticate2.Auth.Dbo.Users;
+using Luticate2.Auth.Interfaces.Groups;
+using Luticate2.Auth.Interfaces.Permissions;
+using Luticate2.Auth.Interfaces.Users;
 using Luticate2.Auth.Middlewares;
 using Luticate2.Utils.Controllers;
 using Luticate2.Utils.Dbo.Basic;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Luticate2.Auth.Controllers
 {
     public static class LuAuthExtensions
     {
-        public static IServiceCollection AddLuticateAuth(this IServiceCollection services, Action<LuUtilsOptionsDbo> optionsDelegate)
+        public const string RoutePrefix = "luticate";
+
+        public const string LuticateItemsLoggedUser = "loggedUser";
+
+        public static IServiceCollection AddLuticateAuth(this IServiceCollection services,
+            Action<LuUtilsOptionsDbo> optionsDelegate, Action<DbContextOptionsBuilder> optionsAction)
         {
             services.AddLuticateUtils(optionsDelegate);
 
-            services.AddSingleton<LuGroupsController>();
-            services.AddSingleton<LuGroupsBusiness>();
-            services.AddSingleton<LuGroupsDataAccess>();
+            services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
+
+            services.AddScoped<ILuLoggedUserAccessor, LuLoggedUserAccessor>();
+            services.AddScoped<LuAttrLoggedUserAccessor>();
+            services.AddScoped<LuAttrArgumentAccessor>();
+
+            services.AddTransient<LuGroupsController>();
+            services.AddTransient<ILuGroupsBusiness, LuGroupsBusiness>();
+            services.AddTransient<LuGroupsDataAccess>();
 
-            services.AddSingleton<LuUsersController>();
+            services.AddTransient<LuUsersController>();
+            services.AddTransient<ILuUsersBusiness, LuUsersBusiness>();
 
-            services.AddDbContext<LuDatabaseContext>();
+            services.AddTransient<ILuPermissionsBusiness, LuPermissionsBusiness>();
+
+            services.AddDbContext<LuAuthDatabaseContext>(options =>
+            {
+                options.UseInternalServiceProvider(new ServiceCollection()
+                    .AddEntityFrameworkNpgsqlLuticate()
+                    .AddEntityFrameworkNpgsql()
+                    .BuildServiceProvider());
+                optionsAction.Invoke(options);
+            }, ServiceLifetime.Transient);
 
             return services;
         }
@@ -30,19 +58,30 @@ namespace Luticate2.Auth.Controllers
         public static IMvcBuilder AddLuticateAuth(this IMvcBuilder builder)
         {
             builder.AddLuticateUtils();
+            builder.Services.Configure<MvcOptions>(
+                options =>
+                {
+                    options.Filters.Add(typeof(LuLoggedUserMiddleware));
+                    options.Filters.Add(typeof(LuPermissionMiddleware));
+                });
             return builder;
         }
 
         public static IApplicationBuilder UseLuticateAuth(this IApplicationBuilder app)
         {
             app.UseLuticateUtils();
-            app.UseMiddleware<LuAuthMiddleware>();
             return app;
         }
 
-        public static object GetLuCurrentUser(this HttpContext context)
+        public static UsersDbo GetLuLoggedUser(this HttpContext context)
+        {
+            return context.GetLuItems()[LuticateItemsLoggedUser] as UsersDbo;
+        }
+
+        public static void SetLuLoggedUser(this HttpContext context, UsersDbo user)
         {
-            return context.GetLuItems()["currentUser"];//TODO
+            throw new Exception($"{user.Id} {user.Username}");
+            context.GetLuItems()[LuticateItemsLoggedUser] = user;
         }
     }
 }

Luticate2.Auth/Controllers/LuGroupsController.cs

@@ -1,24 +1,56 @@
-using Luticate2.Auth.Business;
-using Luticate2.Utils.Controllers;
+using System.ComponentModel.DataAnnotations;
+using Luticate2.Auth.Attributes;
+using Luticate2.Auth.Dbo.Groups;
+using Luticate2.Auth.Dbo.Permissions;
+using Luticate2.Auth.Interfaces.Groups;
 using Luticate2.Utils.Dbo.Basic;
+using Luticate2.Utils.Dbo.PaginatedRequest;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Options;
 
 namespace Luticate2.Auth.Controllers
 {
-    [Route("luticate/groups")]
-    public class LuGroupsController : LuController
+    [Route(LuAuthExtensions.RoutePrefix)]
+    public class LuGroupsController : LuAuthCrudController<ILuGroupsBusiness, LuGroupsAddDbo, LuGroupsDbo, LuGroupsAddDbo, string>
     {
-        private readonly LuGroupsBusiness _luGroupsBusiness;
+        private const string EntityType = LuEntityTypes.LuGroups;
 
-        public LuGroupsController(LuGroupsBusiness luGroupsBusiness, IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(luUtilsOptionsDbo)
+        private const string ReadPermission = LuPermissions.LuGroupsRead;
+
+        private const string WritePermission = LuPermissions.LuGroupsWrite;
+
+        public LuGroupsController(ILuGroupsBusiness busines, IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(busines, luUtilsOptionsDbo)
+        {
+        }
+
+        [LuPermission(ReadPermission, EntityType)]
+        public override LuApiWrapperDbo<LuGroupsDbo> GetSingleById([LuPermissionArg][Required]string id)
+        {
+            return base.GetSingleById(id);
+        }
+
+        [LuPermission(ReadPermission, EntityType)]
+        public override LuApiWrapperDbo<LuPaginatedDbo<LuGroupsDbo>> GetMultiple([Required]LuPaginatedRequestDbo request)
+        {
+            return base.GetMultiple(request);
+        }
+
+        [LuPermission(WritePermission, EntityType)]
+        public override LuApiWrapperDbo<LuGroupsDbo> AddDbo([Required]LuGroupsAddDbo data)
+        {
+            return base.AddDbo(data);
+        }
+
+        [LuPermission(WritePermission, EntityType)]
+        public override LuApiWrapperDbo<LuGroupsDbo> EditSingleByIdDbo([LuPermissionArg][Required]string id, [Required]LuGroupsAddDbo data)
         {
-            _luGroupsBusiness = luGroupsBusiness;
+            return base.EditSingleByIdDbo(id, data);
         }
 
-        public string Get()
+        [LuPermission(WritePermission, EntityType)]
+        public override LuApiWrapperDbo<LuGroupsDbo> Delete([LuPermissionArg][Required]string id)
         {
-            return _luGroupsBusiness.Get();
+            return base.Delete(id);
         }
     }
 }

Luticate2.Auth/Controllers/LuLoggedUserAccessor.cs

@@ -0,0 +1,21 @@
+using Luticate2.Auth.Dbo.Users;
+using Luticate2.Auth.Interfaces.Users;
+using Microsoft.AspNetCore.Http;
+
+namespace Luticate2.Auth.Controllers
+{
+    public class LuLoggedUserAccessor : ILuLoggedUserAccessor
+    {
+        private readonly IHttpContextAccessor _httpContextAccessor;
+
+        public LuLoggedUserAccessor(IHttpContextAccessor httpContextAccessor)
+        {
+            _httpContextAccessor = httpContextAccessor;
+        }
+
+        public UsersDbo GetLoggedUser()
+        {
+            return _httpContextAccessor.HttpContext.GetLuLoggedUser();
+        }
+    }
+}

Luticate2.Auth/Controllers/LuUsersController.cs

@@ -5,16 +5,11 @@ using Microsoft.Extensions.Options;
 
 namespace Luticate2.Auth.Controllers
 {
-    [Route("luticate/users")]
+    [Route(LuAuthExtensions.RoutePrefix)]
     public class LuUsersController : LuController
     {
         public LuUsersController(IOptions<LuUtilsOptionsDbo> luUtilsOptionsDbo) : base(luUtilsOptionsDbo)
         {
         }
-
-        public string Get()
-        {
-            return "users";
-        }
     }
 }

Luticate2.Auth/DataAccess/LuDatabaseContext.cs → Luticate2.Auth/DataAccess/LuAuthDatabaseContext.cs

@@ -3,20 +3,20 @@ using Luticate2.Auth.DataAccess.Models;
 
 namespace Luticate2.Auth.DataAccess
 {
-    public partial class LuDatabaseContext : DbContext
+    public partial class LuAuthDatabaseContext : DbContext
     {
         private readonly string _connectionString;
 
-        public LuDatabaseContext()
+        public LuAuthDatabaseContext()
         {
         }
 
-        public LuDatabaseContext(string connectionString)
+        public LuAuthDatabaseContext(string connectionString)
         {
             _connectionString = connectionString;
         }
 
-        public LuDatabaseContext(DbContextOptions options) :base(options)
+        public LuAuthDatabaseContext(DbContextOptions options) :base(options)
         {
         }
 

Luticate2.Auth/DataAccess/LuGroupsDataAccess.cs

@@ -1,36 +1,50 @@
-using Luticate2.Auth.DataAccess.Models;
+using System;
+using Luticate2.Auth.DataAccess.Models;
 using Luticate2.Auth.Dbo.Groups;
 using Luticate2.Utils.DataAccess;
+using Luticate2.Utils.Dbo.Result;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
 
 namespace Luticate2.Auth.DataAccess
 {
-    public class LuGroupsDataAccess //: LuEfCrudDataAccess<lu_groups, LuGroupsAddDbo, LuGroupsDbo, LuDatabaseContext>
+    public class LuGroupsDataAccess : LuEfCrudDataAccess<lu_groups, LuGroupsAddDbo, LuGroupsDbo, LuGroupsAddDbo, LuAuthDatabaseContext, string>
     {
-//        public LuGroupsDataAccess(LuDatabaseContext db)
-//            : base(db, db.lu_groups)
-//        {
-//        }
+        public LuGroupsDataAccess(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
 
-        public string Get()
+        protected override LuResult<T> HandleError<T>(Exception e)
         {
-            return "groups";
+            if (e is DbUpdateException && e.InnerException is PostgresException)
+            {
+                var pge = (PostgresException) e.InnerException;
+                if (pge.ConstraintName == "lu_groups_name_key")
+                {
+                    return LuResult<T>.Error(LuStatus.InputError, e, "Group name already exists");
+                }
+            }
+            return null;
         }
 
-//        protected override lu_groups GetModelFromTCreate(LuGroupsAddDbo obj)
-//        {
-//            return new lu_groups
-//            {
-//                name = obj.Name
-//            };
-//        }
-//
-//        protected override LuGroupsDbo GetDboFromModel(lu_groups model)
-//        {
-//            return new LuGroupsDbo
-//            {
-//                Id = model.id.ToString(),
-//                Name = model.name
-//            };
-//        }
+        protected override DbSet<lu_groups> GetTable(LuAuthDatabaseContext db)
+        {
+            return db.lu_groups;
+        }
+
+        protected override lu_groups GetModelFromTCreate(LuGroupsAddDbo obj)
+        {
+            return GetModelFromTUpdate(obj, new lu_groups());
+        }
+
+        protected override void EditModelFromTUpdate(LuGroupsAddDbo obj, lu_groups model)
+        {
+            model.name = obj.Name;
+        }
+
+        protected override LuGroupsDbo GetDboFromModel(lu_groups model)
+        {
+            return model.ToDbo();
+        }
     }
 }

Luticate2.Auth/DataAccess/Models/ModelsToDbo.cs

@@ -0,0 +1,21 @@
+using Luticate2.Auth.Dbo.Groups;
+using Luticate2.Utils.Utils;
+
+namespace Luticate2.Auth.DataAccess.Models
+{
+    public static class ModelsToDbo
+    {
+        public static LuGroupsDbo ToDbo(this lu_groups model)
+        {
+            if (model == null)
+            {
+                return null;
+            }
+            return new LuGroupsDbo
+            {
+                Id = model.id.ToDbo(),
+                Name = model.name
+            };
+        }
+    }
+}

Luticate2.Auth/DataAccess/Models/lu_authentication_sources.cs

@@ -18,7 +18,7 @@ namespace Luticate2.Auth.DataAccess.Models
         
         
         
-        public virtual ICollection<lu_users> lu_users_fk { get; set; }
+        public virtual IList<lu_users> lu_users_fk { get; set; }
         
     }
 }

Luticate2.Auth/DataAccess/Models/lu_groups.cs

@@ -14,7 +14,7 @@ namespace Luticate2.Auth.DataAccess.Models
         
         
         
-        public virtual ICollection<lu_verb_users_groups> lu_verb_users_groups_fk { get; set; }
+        public virtual IList<lu_verb_users_groups> lu_verb_users_groups_fk { get; set; }
         
     }
 }

Luticate2.Auth/DataAccess/Models/lu_users.cs

@@ -18,11 +18,13 @@ namespace Luticate2.Auth.DataAccess.Models
         
         public string salt { get; set; }
         
+        public string data { get; set; }
+        
         
         public virtual lu_authentication_sources fk_lu_authentication_sources { get; set; }
         
         
-        public virtual ICollection<lu_verb_users_groups> lu_verb_users_groups_fk { get; set; }
+        public virtual IList<lu_verb_users_groups> lu_verb_users_groups_fk { get; set; }
         
     }
 }

Luticate2.Auth/DataAccess/code-from-ds/DataSource.twig

@@ -3,20 +3,20 @@ using Luticate2.Auth.DataAccess.Models;
 
 namespace Luticate2.Auth.DataAccess
 {
-    public partial class LuDatabaseContext : DbContext
+    public partial class LuAuthDatabaseContext : DbContext
     {
         private readonly string _connectionString;
 
-        public LuDatabaseContext()
+        public LuAuthDatabaseContext()
         {
         }
 
-        public LuDatabaseContext(string connectionString)
+        public LuAuthDatabaseContext(string connectionString)
         {
             _connectionString = connectionString;
         }
 
-        public LuDatabaseContext(DbContextOptions options) :base(options)
+        public LuAuthDatabaseContext(DbContextOptions options) :base(options)
         {
         }
 

Luticate2.Auth/DataAccess/code-from-ds/code-from-ds.json

@@ -1,6 +1,6 @@
 {
     "castFileRelativePath": "Luticate2.Auth/DataAccess/code-from-ds/types-cast.json",
-    "dataSourceRelativePath": "Luticate2.Auth/DataAccess/LuDatabaseContext.cs",
+    "dataSourceRelativePath": "Luticate2.Auth/DataAccess/LuAuthDatabaseContext.cs",
     "modelsRelativePath": "Luticate2.Auth/DataAccess/Models",
     "selection": {
         "tables": [
@@ -59,6 +59,10 @@
                     {
                         "column": "salt",
                         "selected": true
+                    },
+                    {
+                        "column": "data",
+                        "selected": true
                     }
                 ],
                 "table": "lu_users"

Luticate2.Auth/Dbo/Groups/LuGroupsAddDbo.cs

@@ -1,10 +1,10 @@
-using Luticate2.Utils.Dbo;
-using Luticate2.Utils.Dbo.Basic;
+using System.ComponentModel.DataAnnotations;
 
 namespace Luticate2.Auth.Dbo.Groups
 {
     public class LuGroupsAddDbo
     {
+        [Required(AllowEmptyStrings = false)]
         public string Name { get; set; }
     }
 }

Luticate2.Auth/Dbo/Groups/LuGroupsDbo.cs

@@ -1,7 +1,4 @@
-using Luticate2.Utils.Dbo;
-using Luticate2.Utils.Dbo.Basic;
-
-namespace Luticate2.Auth.Dbo.Groups
+namespace Luticate2.Auth.Dbo.Groups
 {
     public class LuGroupsDbo
     {

Luticate2.Auth/Dbo/Permissions/LuEntityTypes.cs

@@ -0,0 +1,9 @@
+namespace Luticate2.Auth.Dbo.Permissions
+{
+    public static class LuEntityTypes
+    {
+        public const string LuUsers = "LuUsers";
+
+        public const string LuGroups = "LuGroups";
+    }
+}

Luticate2.Auth/Dbo/Permissions/LuPermissions.cs

@@ -0,0 +1,9 @@
+namespace Luticate2.Auth.Dbo.Permissions
+{
+    public static class LuPermissions
+    {
+        public const string LuGroupsRead = "LU_GROUPS_READ";
+
+        public const string LuGroupsWrite = "LU_GROUPS_WRITE";
+    }
+}

Luticate2.Auth/Dbo/Users/UsersDbo.cs

@@ -1,10 +1,9 @@
-using Luticate2.Utils.Dbo;
-using Luticate2.Utils.Dbo.Basic;
-
-namespace Luticate2.Auth.Dbo.Users
+namespace Luticate2.Auth.Dbo.Users
 {
     public class UsersDbo
     {
+        public string Id { get; set; }
 
+        public string Username { get; set; }
     }
 }

Luticate2.Auth/Dbo/Users/UsersToken.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace Luticate2.Auth.Dbo.Users
+{
+    public class UsersToken
+    {
+        public string UserId { get; set; }
+
+        public DateTime? NotBefore { get; set; }
+
+        public DateTime? NotAfter { get; set; }
+
+        public object Data { get; set; }
+    }
+}

Luticate2.Auth/Interfaces/Groups/ILuGroupsBusiness.cs

@@ -0,0 +1,10 @@
+using Luticate2.Auth.Dbo.Groups;
+using Luticate2.Utils.Interfaces;
+
+namespace Luticate2.Auth.Interfaces.Groups
+{
+    public interface ILuGroupsBusiness : ILuCrudInterface<LuGroupsAddDbo, LuGroupsDbo, LuGroupsAddDbo, string>
+    {
+
+    }
+}

Luticate2.Auth/Interfaces/Permissions/ILuAttrEntityAccessor.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Luticate2.Auth.Interfaces.Permissions
+{
+    public interface ILuAttrEntityAccessor
+    {
+        object GetEntity(ActionExecutingContext context, object id);
+    }
+}

Luticate2.Auth/Interfaces/Permissions/ILuPermissionsBusiness.cs

@@ -0,0 +1,13 @@
+using Luticate2.Utils.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces.Permissions
+{
+    public interface ILuPermissionsBusiness
+    {
+        LuResult<bool> GetPermissionValue(string permissionName, string srcEntityType, object srcEntity,
+            string dstEntityType, object dstEntity);
+
+        LuResult<bool> GetPermissionEffectiveValue(string permissionName, string srcEntityType, object srcEntity,
+            string dstEntityType, object dstEntity);
+    }
+}

Luticate2.Auth/Interfaces/Permissions/ILuPermissionsProvider.cs

@@ -0,0 +1,13 @@
+using Luticate2.Utils.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces.Permissions
+{
+    public interface ILuPermissionsProvider
+    {
+        LuResult<bool?> GetPermissionValue(string permissionName, string srcEntityType, object srcEntity,
+            string dstEntityType, object dstEntity);
+
+        LuResult<bool?> GetPermissionEffectiveValue(string permissionName, string srcEntityType, object srcEntity,
+            string dstEntityType, object dstEntity);
+    }
+}

Luticate2.Auth/Interfaces/Users/ILuLoggedUserAccessor.cs

@@ -0,0 +1,9 @@
+using Luticate2.Auth.Dbo.Users;
+
+namespace Luticate2.Auth.Interfaces.Users
+{
+    public interface ILuLoggedUserAccessor
+    {
+        UsersDbo GetLoggedUser();
+    }
+}

Luticate2.Auth/Interfaces/Users/ILuUsersBusiness.cs

@@ -0,0 +1,16 @@
+using Luticate2.Auth.Dbo.Users;
+using Luticate2.Utils.Dbo.Result;
+
+namespace Luticate2.Auth.Interfaces.Users
+{
+    public interface ILuUsersBusiness
+    {
+        LuResult<UsersToken> GetToken(string token);
+
+        LuResult<string> RegisterToken(UsersToken token);
+
+        LuResult<UsersToken> UnRegisterToken(string token);
+
+        LuResult<UsersDbo> GetSingleById(string id);
+    }
+}

Luticate2.Auth/Middlewares/LuAuthMiddleware.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc.Controllers;
-using Microsoft.AspNetCore.Mvc.Infrastructure;
-
-namespace Luticate2.Auth.Middlewares
-{
-    public class LuAuthMiddleware
-    {
-        private readonly RequestDelegate _next;
-        private readonly IActionDescriptorCollectionProvider _actionDescriptorCollectionProvider;
-
-        public LuAuthMiddleware(RequestDelegate next, IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
-        {
-            _next = next;
-            _actionDescriptorCollectionProvider = actionDescriptorCollectionProvider;
-        }
-
-        public async Task Invoke(HttpContext context)
-        {
-//            var items = _actionDescriptorCollectionProvider.ActionDescriptors.Items;
-//            var item = items.FirstOrDefault();
-//            var actionDescriptor = item as ControllerActionDescriptor;
-//            if (actionDescriptor != null)
-//            {
-////                actionDescriptor.MethodInfo.GetCustomAttributes()
-//            }
-            await _next.Invoke(context);
-        }
-    }
-}

Luticate2.Auth/Middlewares/LuLoggedUserMiddleware.cs

@@ -0,0 +1,54 @@
+using System;
+using Luticate2.Auth.Controllers;
+using Luticate2.Auth.Dbo.Users;
+using Luticate2.Auth.Interfaces.Users;
+using Luticate2.Utils.Controllers;
+using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Luticate2.Auth.Middlewares
+{
+    public class LuLoggedUserMiddleware : IActionFilter
+    {
+        public const string TokenCookieName = "luticate2-token";
+
+        private readonly ILuUsersBusiness _luUsersBusiness;
+
+        public LuLoggedUserMiddleware(ILuUsersBusiness luUsersBusiness)
+        {
+            _luUsersBusiness = luUsersBusiness;
+        }
+
+        public void OnActionExecuting(ActionExecutingContext context)
+        {
+            var token = context.HttpContext.Request.Cookies[TokenCookieName];
+            var userId = Guid.Empty.ToDbo();
+            if (!string.IsNullOrWhiteSpace(token))
+            {
+                var tokenRes = _luUsersBusiness.GetToken(token);
+                if (tokenRes.Status == LuStatus.NotFound)
+                {
+                    throw new LuResultException(LuResult<object>.Error(LuStatus.LoginError, $"{token}", "Invalid session"));
+                }
+                if (!tokenRes)
+                {
+                    throw new LuResultException(tokenRes.To<object>());
+                }
+                userId = tokenRes.Data.UserId;
+            }
+
+            var userRes = _luUsersBusiness.GetSingleById(userId);
+            if (!userRes)
+            {
+                throw new LuResultException(userRes.To<object>());
+            }
+
+            context.HttpContext.SetLuLoggedUser(userRes.Data);
+        }
+
+        public void OnActionExecuted(ActionExecutedContext context)
+        {
+        }
+    }
+}

Luticate2.Auth/Middlewares/LuPermissionMiddleware.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Reflection;
+using Luticate2.Auth.Attributes;
+using Luticate2.Auth.Interfaces.Permissions;
+using Luticate2.Auth.Interfaces.Users;
+using Luticate2.Utils.Controllers;
+using Luticate2.Utils.Dbo.Result;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Luticate2.Auth.Middlewares
+{
+    public class LuPermissionMiddleware : IActionFilter
+    {
+        private readonly IServiceProvider _serviceProvider;
+        private readonly ILuPermissionsBusiness _luPermissionsBusiness;
+
+        public LuPermissionMiddleware(IServiceProvider serviceProvider, ILuPermissionsBusiness luPermissionsBusiness)
+        {
+            _serviceProvider = serviceProvider;
+            _luPermissionsBusiness = luPermissionsBusiness;
+        }
+
+        public void OnActionExecuting(ActionExecutingContext context)
+        {
+            var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
+            if (actionDescriptor != null)
+            {
+                var attributes = actionDescriptor.MethodInfo.GetCustomAttributes<LuPermissionAttribute>();
+                foreach (var attribute in attributes)
+                {
+                    var srcAccessor = _serviceProvider.GetService(attribute.SrcEntityAccessor) as ILuAttrEntityAccessor;
+                    var dstAccessor = _serviceProvider.GetService(attribute.DstEntityAccessor) as ILuAttrEntityAccessor;
+                    var srcEntity = srcAccessor?.GetEntity(context, attribute.Id);
+                    var dstEntity = dstAccessor?.GetEntity(context, attribute.Id);
+                    var permissionValue = _luPermissionsBusiness.GetPermissionEffectiveValue(attribute.PermissionName,
+                        attribute.SrcEntityType, srcEntity, attribute.DstEntityType, dstEntity);
+                    if (!permissionValue)
+                    {
+                        throw new LuResultException(permissionValue.To<object>());
+                    }
+                    if (!permissionValue.Data)
+                    {
+                        var user = _serviceProvider.GetService<ILuLoggedUserAccessor>().GetLoggedUser();
+                        throw new LuResultException(LuResult<object>.Error(LuStatus.PermissionError,
+                            $"user: {user?.Id} {user?.Username}", "Permission denied"));
+                    }
+                }
+            }
+        }
+
+        public void OnActionExecuted(ActionExecutedContext context)
+        {
+        }
+    }
+}

Luticate2.Auth/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "0.1.0",
+    "version": "0.5.0",
     "buildOptions": {
         "debugType": "portable"
     },

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

@@ -159,7 +159,12 @@ namespace Luticate2.Utils.Controllers
 
         public static IDictionary<object, object> GetLuItems(this HttpContext context)
         {
-            return (IDictionary<object, object>) context.Items["luticateItems"];
+            const string key = "luticateItems";
+            if (!context.Items.ContainsKey(key))
+            {
+                context.Items.Add(key, new Dictionary<object, object>());
+            }
+            return (IDictionary<object, object>) context.Items[key];
         }
     }
 }

TestAuth/Business/LuGroupsBusinessTest.cs

@@ -0,0 +1,24 @@
+using Luticate2.Auth.Dbo.Groups;
+using Luticate2.Auth.Interfaces.Groups;
+using Luticate2.Utils.Dbo.Result;
+using Luticate2.Utils.Utils;
+using Xunit;
+
+namespace TestAuth.Business
+{
+    public class LuGroupsBusinessTest
+    {
+        [Fact]
+        public void Test1()
+        {
+            Tests.TestRealDb<ILuGroupsBusiness>(business =>
+            {
+                var res = business.AddDbo(new LuGroupsAddDbo
+                {
+                    Name = "Test."
+                });
+                Assert.Equal(LuStatus.Success, res.Status);
+            });
+        }
+    }
+}

TestAuth/Properties/AssemblyInfo.cs

@@ -0,0 +1,26 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("TestAuth")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TestAuth")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly: Guid("5064E1F4-DAAF-440E-81C7-6C0BDCF5BCC7")]

TestAuth/TestAuth.xproj

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{5064E1F4-DAAF-440E-81C7-6C0BDCF5BCC7}</ProjectGuid>
+    <ProjectTypeGuids>{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}</ProjectTypeGuids>
+    <RootNamespace>TestAuth</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>

TestAuth/Tests.cs

@@ -0,0 +1,51 @@
+using System;
+using Luticate2.Auth.Controllers;
+using Luticate2.Auth.DataAccess;
+using Luticate2.Utils.DataAccess;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace TestAuth
+{
+    public class Tests
+    {
+        public const string RealDbConnectionString =
+            "User ID=dev;Password=dev;Host=localhost;Port=5432;Database=luticate2;Pooling=true;";
+
+        public static IServiceProvider BuildRealDbServiceProvider()
+        {
+            IServiceCollection serviceCollection = new ServiceCollection();
+            serviceCollection.AddLuticateAuth(dbo =>
+            {
+                dbo.Version = "tests";
+            }, builder =>
+            {
+                builder.UseNpgsql(RealDbConnectionString);
+            });
+            return serviceCollection.BuildServiceProvider();
+        }
+
+        protected static void _TestRealDb(Action<IServiceProvider> func)
+        {
+            var serviceProvider = BuildRealDbServiceProvider();
+            var transactionScope = serviceProvider.GetService<LuEfTransactionScope>();
+            transactionScope.BeginTransaction<LuAuthDatabaseContext>(null);
+            try
+            {
+                func(serviceProvider);
+            }
+            finally
+            {
+                transactionScope.RollbackTransaction<LuAuthDatabaseContext>();
+            }
+        }
+
+        public static void TestRealDb<TService>(Action<TService> func)
+        {
+            _TestRealDb(provider =>
+            {
+                func(provider.GetService<TService>());
+            });
+        }
+    }
+}

TestAuth/project.json

@@ -0,0 +1,28 @@
+{
+    "version": "0.1.0",
+    "buildOptions": {
+        "debugType": "portable"
+    },
+    "dependencies": {
+        "dotnet-test-xunit": "1.0.0-rc2-*",
+        "Luticate2.Auth": "0.5.*",
+        "Moq": "4.6.38-alpha",
+        "System.Runtime.Serialization.Primitives": "4.1.1",
+        "xunit": "2.1.0"
+    },
+    "testRunner": "xunit",
+    "frameworks": {
+        "netcoreapp1.0": {
+            "dependencies": {
+                "Microsoft.NETCore.App": {
+                    "type": "platform",
+                    "version": "1.0.1"
+                }
+            },
+            "imports": [
+                "dotnet5.4",
+                "portable-net451+win8"
+            ]
+        }
+    }
+}

WebApiAuth/Controllers/ValuesController.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+
+namespace WebApiAuth.Controllers
+{
+    [Route("api/[controller]")]
+    public class ValuesController : Controller
+    {
+        // GET api/values
+        [HttpGet]
+        public IEnumerable<string> Get()
+        {
+            return new string[] {"value1", "value2"};
+        }
+
+        // GET api/values/5
+        [HttpGet("{id}")]
+        public string Get(int id)
+        {
+            return "value";
+        }
+
+        // POST api/values
+        [HttpPost]
+        public void Post([FromBody] string value)
+        {
+        }
+
+        // PUT api/values/5
+        [HttpPut("{id}")]
+        public void Put(int id, [FromBody] string value)
+        {
+        }
+
+        // DELETE api/values/5
+        [HttpDelete("{id}")]
+        public void Delete(int id)
+        {
+        }
+    }
+}

WebApiAuth/Program.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Hosting;
+
+namespace WebApiAuth
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            var host = new WebHostBuilder()
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseUrls("http://0.0.0.0:8080")
+                .UseIISIntegration()
+                .UseStartup<Startup>()
+                .Build();
+
+            host.Run();
+        }
+    }
+}

WebApiAuth/Properties/AssemblyInfo.cs

@@ -0,0 +1,26 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("WebApiAuth")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("WebApiAuth")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly: Guid("D71E5DEE-6122-45D0-8A09-C05F79B1A17E")]

WebApiAuth/Startup.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Luticate2.Auth.Controllers;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace WebApiAuth
+{
+    public class Startup
+    {
+        public Startup(IHostingEnvironment env)
+        {
+            var builder = new ConfigurationBuilder()
+                .SetBasePath(env.ContentRootPath)
+                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
+
+            if (env.IsEnvironment("Development"))
+            {
+                // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
+                builder.AddApplicationInsightsSettings(developerMode: true);
+            }
+
+            builder.AddEnvironmentVariables();
+            Configuration = builder.Build();
+        }
+
+        public IConfigurationRoot Configuration { get; }
+
+        // This method gets called by the runtime. Use this method to add services to the container
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddLuticateAuth(options => options.Version = "dev", options =>
+            {
+                options.UseNpgsql(Configuration.GetConnectionString("default"));
+            });
+
+            services.AddMvc()
+                .AddLuticateAuth();
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
+        {
+            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
+            loggerFactory.AddDebug();
+
+            app.UseLuticateAuth();
+
+            app.UseMvc();
+        }
+    }
+}

WebApiAuth/WebApiAuth.xproj

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{D71E5DEE-6122-45D0-8A09-C05F79B1A17E}</ProjectGuid>
+    <ProjectTypeGuids>{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}</ProjectTypeGuids>
+    <RootNamespace>WebApiAuth</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>

WebApiAuth/appsettings.Development.json

@@ -0,0 +1,14 @@
+{
+    "Logging": {
+        "IncludeScopes": false,
+        "LogLevel": {
+            "Default": "Debug",
+            "System": "Information",
+            "Microsoft": "Information",
+            "Microsoft.EntityFrameworkCore.Storage.IRelationalCommandBuilderFactory": "Information"
+        }
+    },
+    "ConnectionStrings": {
+        "default":  "User ID=dev;Password=dev;Host=localhost;Port=5432;Database=luticate2;Pooling=true;ApplicationName=WebApiAuthDev"
+    }
+}

WebApiAuth/appsettings.json

@@ -0,0 +1,15 @@
+{
+    "Logging": {
+        "IncludeScopes": false,
+        "LogLevel": {
+            "Default": "Information",
+            "System": "Information",
+            "Microsoft": "Information",
+            "Microsoft.EntityFrameworkCore.Storage.IRelationalCommandBuilderFactory": "Error",
+            "Microsoft.AspNetCore.Mvc.Internal.ObjectResultExecutor": "Error"
+        }
+    },
+    "ConnectionStrings": {
+        "default":  "User ID=POSTGRES_USER;Password=POSTGRES_PASSWORD;Host=POSTGRES_HOST;Port=5432;Database=POSTGRES_DB;Pooling=true;ApplicationName=WebApiUtils"
+    }
+}

WebApiAuth/project.json

@@ -0,0 +1,55 @@
+{
+    "dependencies": {
+        "TestAuth": "0.1.*",
+        "Microsoft.ApplicationInsights.AspNetCore": "1.0.2",
+        "Microsoft.AspNetCore.Mvc": "1.1.0",
+        "Microsoft.AspNetCore.Routing": "1.1.0",
+        "Microsoft.AspNetCore.Server.IISIntegration": "1.1.0",
+        "Microsoft.AspNetCore.Server.Kestrel": "1.1.0",
+        "Microsoft.Extensions.Configuration.EnvironmentVariables": "1.1.0",
+        "Microsoft.Extensions.Configuration.FileExtensions": "1.1.0",
+        "Microsoft.Extensions.Configuration.Json": "1.1.0",
+        "Microsoft.Extensions.Logging": "1.1.0",
+        "Microsoft.Extensions.Logging.Console": "1.1.0",
+        "Microsoft.Extensions.Logging.Debug": "1.1.0",
+        "Microsoft.Extensions.Options.ConfigurationExtensions": "1.1.0",
+        "Microsoft.NETCore.App": {
+            "version": "1.0.1",
+            "type": "platform"
+        }
+    },
+    "tools": {
+        "Microsoft.AspNetCore.Server.IISIntegration.Tools": "1.0.0-preview2-final"
+    },
+    "frameworks": {
+        "netcoreapp1.0": {
+            "imports": [
+                "dotnet5.6",
+                "portable-net45+win8"
+            ]
+        }
+    },
+    "buildOptions": {
+        "emitEntryPoint": true,
+        "debugType": "portable",
+        "preserveCompilationContext": true
+    },
+    "runtimeOptions": {
+        "configProperties": {
+            "System.GC.Server": true
+        }
+    },
+    "publishOptions": {
+        "include": [
+            "wwwroot",
+            "**/*.cshtml",
+            "appsettings.json",
+            "web.config"
+        ]
+    },
+    "scripts": {
+        "postpublish": [
+            "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%"
+        ]
+    }
+}

WebApiAuth/web.config

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+
+  <!--
+    Configure your application settings in appsettings.json. Learn more at http://go.microsoft.com/fwlink/?LinkId=786380
+  -->
+
+  <system.webServer>
+    <handlers>
+      <add name="aspNetCore" path="*" verb="*" modules="AspNetCoreModule" resourceType="Unspecified"/>
+    </handlers>
+    <aspNetCore processPath="%LAUNCHER_PATH%" arguments="%LAUNCHER_ARGS%" stdoutLogEnabled="false" stdoutLogFile=".\logs\stdout" forwardWindowsAuthToken="false"/>
+  </system.webServer>
+</configuration>

luticate2.sln

@@ -11,6 +11,10 @@ Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "TestUtils", "TestUtils\Test
 EndProject
 Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "WebApiUtils", "WebApiUtils\WebApiUtils.xproj", "{8380B793-B696-4979-A892-1BCAFA66A64E}"
 EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "WebApiAuth", "WebApiAuth\WebApiAuth.xproj", "{D71E5DEE-6122-45D0-8A09-C05F79B1A17E}"
+EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "TestAuth", "TestAuth\TestAuth.xproj", "{5064E1F4-DAAF-440E-81C7-6C0BDCF5BCC7}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -33,6 +37,14 @@ Global
 		{8380B793-B696-4979-A892-1BCAFA66A64E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8380B793-B696-4979-A892-1BCAFA66A64E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8380B793-B696-4979-A892-1BCAFA66A64E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D71E5DEE-6122-45D0-8A09-C05F79B1A17E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D71E5DEE-6122-45D0-8A09-C05F79B1A17E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D71E5DEE-6122-45D0-8A09-C05F79B1A17E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D71E5DEE-6122-45D0-8A09-C05F79B1A17E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5064E1F4-DAAF-440E-81C7-6C0BDCF5BCC7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5064E1F4-DAAF-440E-81C7-6C0BDCF5BCC7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5064E1F4-DAAF-440E-81C7-6C0BDCF5BCC7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5064E1F4-DAAF-440E-81C7-6C0BDCF5BCC7}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE