Initial commit

C#/WebApplication/Logic/CustomerLogic.cs

@@ -0,0 +1,72 @@
+using System.Collections.Generic;
+using System.Linq;
+using WebApplication.Modules;
+using WebApplication.Repositorys.Interfaces;
+
+namespace WebApplication.Logic {
+    public interface ICustomerLogic {
+        ILogicResult<Customer> AddCustomer(CustomerEditor editor);
+        ILogicResult RemoveCustomer(string id, string session);
+        ILogicResult EditCustomer(string id, CustomerEditor editor, string session);
+        ILogicResult<Customer> GetCustomer(string id, string session);
+        ILogicResult<IEnumerable<Customer>> GetCustomers();
+        ILogicResult<Session> CreateCustomerSession(string customer);
+        ILogicResult DeleteCustomerSession(string customer, string session);
+        ILogicResult<Session> Login(CustomerLogin login);
+    }
+    
+    public class CustomerLogic : ICustomerLogic {
+        private readonly ICustomerRepository _customers;
+        private readonly ISessionRepository _sessions;
+
+        public CustomerLogic(ICustomerRepository customers, ISessionRepository sessions) {
+            _customers = customers;
+            _sessions = sessions;
+        }
+        
+        public ILogicResult<Customer> AddCustomer(CustomerEditor editor) {
+            return LogicResult<Customer>.Ok(_customers.AddCustomer(editor));
+        }
+
+        public ILogicResult RemoveCustomer(string id, string session) {
+            if (!ValidateSession(session, id)) return LogicResult.Forbidden();
+            _customers.RemoveCustomer(id);
+            return LogicResult.Ok();
+        }
+
+        public ILogicResult EditCustomer(string id, CustomerEditor editor, string session) {
+            if (!ValidateSession(session, id)) return LogicResult.Forbidden();
+            _customers.EditCustomer(id, editor);
+            return LogicResult.Ok();
+        }
+
+        public ILogicResult<Customer> GetCustomer(string id, string session) {
+            if (!ValidateSession(session, id)) return LogicResult<Customer>.Forbidden();
+            return LogicResult<Customer>.Ok(_customers.GetCustomer(id));
+        }
+
+        public ILogicResult<IEnumerable<Customer>> GetCustomers() {
+            return LogicResult<IEnumerable<Customer>>.Ok(_customers.GetCustomers());
+        }
+
+        public ILogicResult<Session> CreateCustomerSession(string customer) {
+            return LogicResult<Session>.Ok(_sessions.CreateSession(customer));
+        }
+
+        public ILogicResult DeleteCustomerSession(string customer, string session) {
+            if (!ValidateSession(session, customer)) return LogicResult.Forbidden();
+            _sessions.RemoveSession(_sessions.GetSession(session));
+            return LogicResult.Ok();
+        }
+
+        public ILogicResult<Session> Login(CustomerLogin login) {
+            var customer = _customers.GetCustomers().FirstOrDefault(c => c.Email == login.Email);
+            if (customer is null) return LogicResult<Session>.NotFound();
+            return !customer.Password.Equals(login.Password) ? LogicResult<Session>.Forbidden() : CreateCustomerSession(customer.Guid);
+        }
+
+        private bool ValidateSession(string session, string customerToAccess) {
+            return _sessions.ValidateSession(_sessions.GetSession(session), customerToAccess);
+        }
+    }
+}

C#/WebApplication/Logic/LogicResult/ControllerBaseExtension.cs

@@ -0,0 +1,54 @@
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Net;
+
+public static class ControllerBaseExtension
+{
+    public static ActionResult FromLogicResult(this ControllerBase controller, ILogicResult result)
+    {
+        switch (result.State)
+        {
+            case LogicResultState.Ok:
+                return controller.Ok();
+
+            case LogicResultState.BadRequest:
+                return controller.StatusCode((int)HttpStatusCode.BadRequest, result.Message);
+
+            case LogicResultState.Forbidden:
+                return controller.StatusCode((int)HttpStatusCode.Forbidden, result.Message);
+
+            case LogicResultState.NotFound:
+                return controller.StatusCode((int)HttpStatusCode.NotFound, result.Message);
+
+            case LogicResultState.Conflict:
+                return controller.StatusCode((int)HttpStatusCode.Conflict, result.Message);
+
+            default:
+                throw new Exception("An unhandled result has occurred as a result of a service call.");
+        }
+    }
+
+    public static ActionResult FromLogicResult<T>(this ControllerBase controller, ILogicResult<T> result)
+    {
+        switch (result.State)
+        {
+            case LogicResultState.Ok:
+                return controller.Ok(result.Data);
+
+            case LogicResultState.BadRequest:
+                return controller.StatusCode((int)HttpStatusCode.BadRequest, result.Message);
+
+            case LogicResultState.Forbidden:
+                return controller.StatusCode((int)HttpStatusCode.Forbidden, result.Message);
+
+            case LogicResultState.NotFound:
+                return controller.StatusCode((int)HttpStatusCode.NotFound, result.Message);
+
+            case LogicResultState.Conflict:
+                return controller.StatusCode((int)HttpStatusCode.Conflict, result.Message);
+
+            default:
+                throw new Exception("An unhandled result has occurred as a result of a service call.");
+        }
+    }
+}

C#/WebApplication/Logic/LogicResult/ILogicResult.cs

@@ -0,0 +1,8 @@
+public interface ILogicResult
+{
+    LogicResultState State { get; set; }
+
+    string Message { get; set; }
+
+    bool IsSuccessful { get; }
+}

C#/WebApplication/Logic/LogicResult/ILogicResult{T}.cs

@@ -0,0 +1,10 @@
+public interface ILogicResult<T>
+{
+    LogicResultState State { get; set; }
+
+    T Data { get; set; }
+
+    string Message { get; set; }
+
+    bool IsSuccessful { get; }
+}

C#/WebApplication/Logic/LogicResult/LogicResult.cs

@@ -0,0 +1,108 @@
+internal class LogicResult : ILogicResult
+{
+    public LogicResultState State { get; set; }
+
+    public string Message { get; set; }
+
+    public bool IsSuccessful
+    {
+        get
+        {
+            return this.State == LogicResultState.Ok;
+        }
+    }
+
+    public static LogicResult Ok()
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.Ok
+        };
+    }
+
+    public static LogicResult BadRequest()
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.BadRequest
+        };
+    }
+
+    public static LogicResult BadRequest(string message)
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.BadRequest,
+            Message = message
+        };
+    }
+
+    public static LogicResult Forbidden()
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.Forbidden
+        };
+    }
+
+    public static LogicResult Forbidden(string message)
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.Forbidden,
+            Message = message
+        };
+    }
+
+    public static LogicResult NotFound()
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.NotFound
+        };
+    }
+
+    public static LogicResult NotFound(string message)
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.NotFound,
+            Message = message
+        };
+    }
+
+    public static LogicResult Conflict()
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.Conflict
+        };
+    }
+
+    public static LogicResult Conflict(string message)
+    {
+        return new LogicResult()
+        {
+            State = LogicResultState.Conflict,
+            Message = message
+        };
+    }
+
+    public static LogicResult Forward(LogicResult result)
+    {
+        return new LogicResult()
+        {
+            State = result.State,
+            Message = result.Message
+        };
+    }
+
+    public static LogicResult Forward<T>(ILogicResult<T> result)
+    {
+        return new LogicResult()
+        {
+            State = result.State,
+            Message = result.Message
+        };
+    }
+}

C#/WebApplication/Logic/LogicResult/LogicResultState.cs

@@ -0,0 +1,8 @@
+public enum LogicResultState
+{
+    Ok,
+    BadRequest,
+    Forbidden,
+    NotFound,
+    Conflict
+}

C#/WebApplication/Logic/LogicResult/LogicResult{T}.cs

@@ -0,0 +1,119 @@
+internal class LogicResult<T> : ILogicResult<T>
+{
+    public LogicResultState State { get; set; }
+
+    public T Data { get; set; }
+
+    public string Message { get; set; }
+
+    public bool IsSuccessful
+    {
+        get
+        {
+            return this.State == LogicResultState.Ok;
+        }
+    }
+
+    public static LogicResult<T> Ok()
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.Ok
+        };
+    }
+
+    public static LogicResult<T> Ok(T result)
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.Ok,
+            Data = result
+        };
+    }
+
+    public static LogicResult<T> BadRequest()
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.BadRequest
+        };
+    }
+
+    public static LogicResult<T> BadRequest(string message)
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.BadRequest,
+            Message = message
+        };
+    }
+
+    public static LogicResult<T> Forbidden()
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.Forbidden
+        };
+    }
+
+    public static LogicResult<T> Forbidden(string message)
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.Forbidden,
+            Message = message
+        };
+    }
+
+    public static LogicResult<T> NotFound()
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.NotFound
+        };
+    }
+
+    public static LogicResult<T> NotFound(string message)
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.NotFound,
+            Message = message
+        };
+    }
+
+    public static LogicResult<T> Conflict()
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.Conflict
+        };
+    }
+
+    public static LogicResult<T> Conflict(string message)
+    {
+        return new LogicResult<T>()
+        {
+            State = LogicResultState.Conflict,
+            Message = message
+        };
+    }
+
+    public static LogicResult<T> Forward(ILogicResult result)
+    {
+        return new LogicResult<T>()
+        {
+            State = result.State,
+            Message = result.Message
+        };
+    }
+
+    public static LogicResult<T> Forward<T2>(ILogicResult<T2> result)
+    {
+        return new LogicResult<T>()
+        {
+            State = result.State,
+            Message = result.Message
+        };
+    }
+}