diff --git a/exercise.wwwapi/Configuration/ConfigurationSettings.cs b/exercise.wwwapi/Configuration/ConfigurationSettings.cs
new file mode 100644
index 0000000..5f84d68
--- /dev/null
+++ b/exercise.wwwapi/Configuration/ConfigurationSettings.cs
@@ -0,0 +1,15 @@
+namespace exercise.wwwapi.Configuration
+{
+    public class ConfigurationSettings : IConfigurationSettings
+    {
+        IConfiguration _conf; 
+        public ConfigurationSettings() 
+        {
+            _conf = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
+        }
+        public T GetValue<T>(string key)
+        {
+            return _conf.GetValue<T>(key)!;
+        }
+    }
+}
diff --git a/exercise.wwwapi/Configuration/IConfigurationSettings.cs b/exercise.wwwapi/Configuration/IConfigurationSettings.cs
new file mode 100644
index 0000000..790e098
--- /dev/null
+++ b/exercise.wwwapi/Configuration/IConfigurationSettings.cs
@@ -0,0 +1,7 @@
+namespace exercise.wwwapi.Configuration
+{
+    public interface IConfigurationSettings
+    {
+        public T GetValue<T>(string key);
+    }
+}
diff --git a/exercise.wwwapi/DTO/AbstractClasses/DTO_Auth_Request.cs b/exercise.wwwapi/DTO/AbstractClasses/DTO_Auth_Request.cs
new file mode 100644
index 0000000..abbb327
--- /dev/null
+++ b/exercise.wwwapi/DTO/AbstractClasses/DTO_Auth_Request.cs
@@ -0,0 +1,39 @@
+using System.Net;
+using System.Text.Json.Serialization;
+using api_cinema_challenge.Models.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Configuration;
+using exercise.wwwapi.Payload;
+
+namespace api_cinema_challenge.DTO.Interfaces
+{
+    /// <summary>
+    /// Special base class inherited by anything requireing authentication, returns a payload with token; 
+    /// </summary>
+    public abstract class DTO_Auth_Request<Model_Type> 
+        where Model_Type : class,ICustomModel, new()
+    {
+        [JsonIgnore]
+        private string? _auth_token = null;
+        public static async Task<object?> authenticate(DTO_Auth_Request<Model_Type> dto, IRepository<Model_Type> repo, IConfigurationSettings conf)
+        {
+            Model_Type? model = await dto.ReturnCreatedInstanceModel(repo);
+            if (model == null) throw new HttpRequestException("requested object does not exist", null,  HttpStatusCode.NotFound);
+            if (!await dto.VerifyRequestedModelAgainstDTO(repo, model)) throw new HttpRequestException("Wrong password", null, HttpStatusCode.NotFound);
+            
+            dto._auth_token = await dto.CreateAndReturnJWTToken(repo, model, conf);
+            return dto._auth_token;
+        }
+        public static Payload<string, string> toPayloadAuth(DTO_Auth_Request<Model_Type>  dto)
+        {
+            var p = new Payload<string, string>();
+            p.Data = dto._auth_token;
+            p.Status = dto._auth_token != null ? "success" : "failure";
+            return p;
+        }
+
+        protected abstract Task<Model_Type?> ReturnCreatedInstanceModel(IRepository<Model_Type> repo);
+        protected abstract Task<bool> VerifyRequestedModelAgainstDTO(IRepository<Model_Type> repo, Model_Type model);
+        protected abstract Task<string> CreateAndReturnJWTToken(IRepository<Model_Type> repo, Model_Type model, IConfigurationSettings conf);
+    }
+}
diff --git a/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_create.cs b/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_create.cs
new file mode 100644
index 0000000..42ab345
--- /dev/null
+++ b/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_create.cs
@@ -0,0 +1,30 @@
+using System.Security.Claims;
+using api_cinema_challenge.Models.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+
+namespace api_cinema_challenge.DTO.Interfaces
+{
+    /// <summary>
+    /// Special base class for all DTO that preforms a new Creation
+    /// </summary>
+    public abstract class DTO_Request_create<Model_type>
+        where Model_type : class, ICustomModel, new()
+    {
+        protected abstract Func<IQueryable<Model_type>, IQueryable<Model_type>> GetEntryWithIncludes(Model_type createdEntity , params object[] id);
+        public abstract Model_type CreateAndReturnNewInstance(ClaimsPrincipal user,params object[] pathargs);
+        protected virtual bool CheckConditionForValidCreate(ClaimsPrincipal user, Model_type createdModel,params object[] pathargs)
+        {
+            return true;
+        }
+        public async Task<Model_type> Create(IRepository<Model_type> repo, ClaimsPrincipal user, params object[] pathargs)
+        {
+            var model = CreateAndReturnNewInstance(user, pathargs);
+            if(!CheckConditionForValidCreate(user, model, pathargs)) throw new HttpRequestException($"Create condition was not met for creating {typeof(Model_type).Name}", null, System.Net.HttpStatusCode.BadRequest);
+            var createdEntity = await repo.CreateEntry(model);
+            if (createdEntity == null) throw new HttpRequestException("Bad Creation request", null, System.Net.HttpStatusCode.BadRequest);
+
+            return await repo.GetEntry(GetEntryWithIncludes(createdEntity, pathargs));
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_delete.cs b/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_delete.cs
new file mode 100644
index 0000000..14be7a6
--- /dev/null
+++ b/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_delete.cs
@@ -0,0 +1,28 @@
+using System.Net;
+using System.Security.Claims;
+using api_cinema_challenge.Models;
+using api_cinema_challenge.Models.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+
+namespace api_cinema_challenge.DTO.Interfaces
+{
+    /// <summary>
+    /// Special base class for all DTO that preforms a deletion
+    /// </summary>
+    public abstract class DTO_Request_delete<Model_Type>
+        where Model_Type : class, ICustomModel, new()
+    {
+        protected abstract Func<IQueryable<Model_Type>, IQueryable<Model_Type>> getId(params object[] id);
+        protected abstract bool VerifRightsToDelete(ClaimsPrincipal user, Model_Type fetchedModel);
+        public async Task<Model_Type> Delete(IRepository<Model_Type> repo, ClaimsPrincipal user,params object[] id)
+        {
+            var query = getId(id);
+            var fetchedModel = await repo.GetEntry(query);
+            if (fetchedModel == null) throw new HttpRequestException("requested object does not exist", null, HttpStatusCode.NotFound);
+            if (!VerifRightsToDelete(user, fetchedModel)) throw new HttpRequestException($"requested object is not owned by user {int.Parse(user.FindFirst(ClaimTypes.Sid)!.Value)}", null, HttpStatusCode.Unauthorized);
+
+            return await repo.DeleteEntry(query);
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_update.cs b/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_update.cs
new file mode 100644
index 0000000..810328c
--- /dev/null
+++ b/exercise.wwwapi/DTO/AbstractClasses/DTO_Request_update.cs
@@ -0,0 +1,28 @@
+using System.Net;
+using System.Security.Claims;
+using api_cinema_challenge.Models.Interfaces;
+using api_cinema_challenge.Repository;
+
+namespace api_cinema_challenge.DTO.Interfaces
+{
+    /// <summary>
+    /// Special base class for all DTO that updates a entity
+    /// </summary>
+    public abstract class DTO_Request_update<Model_Type>
+        where Model_Type : class,ICustomModel, new()
+    {
+        protected abstract Func<IQueryable<Model_Type>, IQueryable<Model_Type>> getId(params object[] id);
+        protected abstract bool VerifRightsToUpdate(ClaimsPrincipal user, Model_Type fetchedModel);
+        protected abstract Model_Type CreateAndReturnUpdatedInstance(Model_Type originalModelData);
+        public async Task<Model_Type> Update(IRepository<Model_Type> repo, ClaimsPrincipal user, params object[] id)
+        {
+            var query = getId(id);
+            var fetchedModel = await repo.GetEntry(query);
+            if (!VerifRightsToUpdate(user, fetchedModel)) throw new HttpRequestException($"requested object is not owned by user {int.Parse(user.FindFirst(ClaimTypes.Sid)!.Value)}", null, HttpStatusCode.Unauthorized);
+            if (fetchedModel == null) throw new HttpRequestException("requested object does not exist", null, HttpStatusCode.NotFound);
+            var model = CreateAndReturnUpdatedInstance(fetchedModel);
+            
+            return await repo.UpdateEntry(query, model);
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/AbstractClasses/DTO_Response.cs b/exercise.wwwapi/DTO/AbstractClasses/DTO_Response.cs
new file mode 100644
index 0000000..f02da66
--- /dev/null
+++ b/exercise.wwwapi/DTO/AbstractClasses/DTO_Response.cs
@@ -0,0 +1,194 @@
+using System.Diagnostics;
+using api_cinema_challenge.Models;
+using api_cinema_challenge.Models.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+using exercise.wwwapi.Payload;
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace api_cinema_challenge.DTO.Interfaces
+{
+    public interface IDTO_Defines_Include<Model_Type>
+        where Model_Type : class, ICustomModel
+    {
+        public static abstract Func<IQueryable<Model_Type>, IQueryable<Model_Type>> _includeData();
+    }
+    /// <summary>
+    /// The abstract DTO_Response class contains many generic functions to turn a model into a DTO, and package into a payload...
+    /// </summary>
+    public abstract class DTO_Response<DTO_Type, Model_Type> 
+        where DTO_Type : DTO_Response<DTO_Type, Model_Type>, new()
+        where Model_Type : class, ICustomModel
+    {
+        public DTO_Response() { }
+        protected abstract void _Initialize(Model_Type model);
+
+        public void Initialize(Model_Type model)
+        {
+            try
+            {
+                _Initialize(model);
+            }
+            catch(ArgumentNullException ex)
+            {
+                throw new NotImplementedException($"{this.GetType().Name} does not implement the `{nameof(IDTO_Defines_Include<Model_Type>)}` interface; Implement that interface to avoid null references by returning the include query");
+            }
+            catch (NullReferenceException ex)
+            {
+                throw new NotImplementedException($"{this.GetType().Name} does not implement the `{nameof(IDTO_Defines_Include<Model_Type>)}` interface; Implement that interface to avoid null references by returning the include query");
+            }
+        }
+
+        public static async Task<IEnumerable<DTO_Type>> Gets(IRepository<Model_Type> repo)
+        {
+            IEnumerable<Model_Type>  list = await repo.GetEntries();
+
+            return list.Select(x => { var a = new DTO_Type(); a.Initialize(x); return a; }).ToList();
+        }
+        public static async Task<IEnumerable<DTO_Type>> Gets(IRepository<Model_Type> repo, Func<IQueryable<Model_Type>, IQueryable<Model_Type>>? WhereQuery)
+        {
+            IEnumerable<Model_Type> list = await repo.GetEntries(WhereQuery);
+
+            return list.Select(x => { var a = new DTO_Type(); a.Initialize(x); return a; }).ToList();
+        }
+
+        public static async Task<IEnumerable<DTO_Type>> Gets<T>(IRepository<T> repo, Func<IQueryable<T>, IQueryable<T>>? WhereQuery = null, Func<IEnumerable<T>, IEnumerable<Model_Type>>? selectorfunc = null)
+            where T : class, ICustomModel
+        {
+            IEnumerable<Model_Type> list;
+            if (WhereQuery == null) list = selectorfunc!.Invoke(await repo.GetEntries()).ToList();
+            else
+            {
+                list = selectorfunc.Invoke(await repo.GetEntries(WhereQuery)).ToList();
+                
+            }
+
+            return list.Select(x => { var a = new DTO_Type(); a.Initialize(x); return a; }).ToList();
+        }
+        
+        public static IEnumerable<DTO_Type> Gets<T>(IEnumerable<T> models, Func<IEnumerable<T>, IEnumerable<Model_Type>>? selectorfunc)
+            where T : class, ICustomModel
+        {
+            IEnumerable<Model_Type> list = selectorfunc.Invoke(models).ToList();
+    
+            return list.Select(x => { var a = new DTO_Type(); a.Initialize(x); return a; }).ToList();
+        }
+
+        public static IEnumerable<DTO_Type> Gets(IEnumerable<Model_Type> models)
+        {
+            return models.Select(x => { var a = new DTO_Type(); a.Initialize(x); return a; }).ToList();
+        }
+
+        public static Payload<DTO_Type,Model_Type> toPayload(Model_Type model, string status = "success")
+        {
+            var a = new DTO_Type();
+            a.Initialize(model);
+
+            var p = new Payload<DTO_Type,Model_Type>();
+            p.Data = a;
+            p.Status = status;
+            return p;
+        }
+        public static Payload<IEnumerable<DTO_Type>, Model_Type> toPayload(IEnumerable<Model_Type> models, string status = "success")
+        {
+            var list = models.Select(x => { var a = new DTO_Type(); a.Initialize(x); return a; }).ToList();
+
+            var p = new Payload<IEnumerable<DTO_Type>,Model_Type>();
+            p.Data = list;
+            p.Status = status;
+            return p;
+        }
+        public static Payload<IEnumerable<DTO_Type>, Model_Type> toPayload(IEnumerable<DTO_Type> modelsDtoList, string status = "success")
+        {
+            var p = new Payload<IEnumerable<DTO_Type>,Model_Type>();
+            p.Data = modelsDtoList;
+            p.Status = status;
+            return p;
+        }
+
+        public static async Task<Payload<IEnumerable<DTO_Type>, Model_Type>> toPayload(IRepository<Model_Type> repo, string status = "success")
+            
+        {
+            try
+            {
+                var p = new Payload<IEnumerable<DTO_Type>, Model_Type>();
+                var include_interf = typeof(DTO_Type).GetInterface(typeof(IDTO_Defines_Include<Model_Type>).Name);
+                if (include_interf != null) 
+                {
+                    var methodInfo = typeof(DTO_Type).GetMethod(
+                            nameof(IDTO_Defines_Include<Model_Type>._includeData), 
+                            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
+                    try
+                    {
+                        var queryArgs = (Func<IQueryable<Model_Type>, IQueryable<Model_Type>>)methodInfo.Invoke(null,null);
+                        p.Data = await Gets(repo, queryArgs);
+                    }
+                    catch(ArgumentNullException ex)
+                    {
+                        throw new NotImplementedException($"{typeof(DTO_Type).Name} does not Include all members of {ex.TargetSite.DeclaringType.Name} in their `{nameof(IDTO_Defines_Include<Model_Type>)}` function; Ensure to include all required includes for {ex.TargetSite.DeclaringType.Name} dto class");
+                    }
+                    catch(NullReferenceException ex)
+                    {
+                        throw new NotImplementedException($"{typeof(DTO_Type).Name} does not Include all members of {ex.TargetSite.DeclaringType.Name} in their `{nameof(IDTO_Defines_Include<Model_Type>)}` function; Ensure to include all required includes for {ex.TargetSite.DeclaringType.Name} dto class");
+                    }
+                }
+                else
+                    p.Data = await Gets(repo);
+                p.Status = status;
+                return p;
+            }
+            catch (HttpRequestException ex)
+            {
+                var p = new Payload<IEnumerable<DTO_Type>, Model_Type>();
+                p.Data = [];
+                p.Status = "Failure";
+                return p;
+            }
+
+        }
+
+        public static async Task<Payload<IEnumerable<DTO_Type>, Model_Type>> toPayload<T>(IRepository<T> repo, Func<IQueryable<T>, IQueryable<T>> WhereQuery
+            , Func<IEnumerable<T>, IEnumerable<Model_Type>>? selectorfunc
+            , string status = "success"
+            )
+            where T : class, ICustomModel 
+        {
+
+            try
+            {
+                var p = new Payload<IEnumerable<DTO_Type>, Model_Type>();
+                p.Data = await Gets<T>(repo, WhereQuery, selectorfunc);
+                p.Status = status;
+                return p;
+            }
+            catch (HttpRequestException ex)
+            {
+                var p = new Payload<IEnumerable<DTO_Type>, Model_Type>();
+                p.Data = [];
+                p.Status = "Failure";
+                return p;
+            }
+        }
+
+        public static async Task<Payload<IEnumerable<DTO_Type>, Model_Type>> toPayload(IRepository<Model_Type> repo, Func<IQueryable<Model_Type>, IQueryable<Model_Type>>? WhereQuery, string status = "success")
+        {
+            try
+            {
+                var p = new Payload<IEnumerable<DTO_Type>, Model_Type>();
+                p.Data = await Gets(repo, WhereQuery);
+                p.Status = status;
+                return p;
+            }
+            catch (HttpRequestException ex)
+            {
+                var p = new Payload<IEnumerable<DTO_Type>, Model_Type>();
+                p.Data = [];
+                p.Status = "Failure";
+                return p;
+            }
+
+        }
+
+        
+    }
+}
diff --git a/exercise.wwwapi/DTO/Request/Auth_Login_User.cs b/exercise.wwwapi/DTO/Request/Auth_Login_User.cs
new file mode 100644
index 0000000..8546170
--- /dev/null
+++ b/exercise.wwwapi/DTO/Request/Auth_Login_User.cs
@@ -0,0 +1,52 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Configuration;
+using exercise.wwwapi.Models;
+using Microsoft.IdentityModel.Tokens;
+
+namespace exercise.wwwapi.DTO.Request
+{
+    public class Auth_Login_User : DTO_Auth_Request<User>
+    {
+        public string Username { get; set; }
+        public string Password { get; set; }
+
+        protected override async Task<string> CreateAndReturnJWTToken(IRepository<User> repo, User model, IConfigurationSettings conf)
+        {
+            List<Claim> claims = new List<Claim>
+            {
+                new Claim(ClaimTypes.Sid, model.Id.ToString()),
+                new Claim(ClaimTypes.Name, model.Username),
+                new Claim(ClaimTypes.Email, model.Email),
+                new Claim(ClaimTypes.Role, model.Role), 
+            };
+
+            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(conf.GetValue<string>("AppSettings:Token")!));
+            var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
+            var token = new JwtSecurityToken(
+                claims: claims,
+                expires: DateTime.Now.AddDays(1),
+                signingCredentials: credentials
+                );
+            var jwt = new JwtSecurityTokenHandler().WriteToken(token);
+            return jwt;
+        }
+
+        protected override async Task<User?> ReturnCreatedInstanceModel(IRepository<User> repo)
+        {
+            return await repo.GetEntry(x => x.Where(x => x.Username == this.Username));
+        }
+
+        protected override async Task<bool> VerifyRequestedModelAgainstDTO(IRepository<User> repo, User model)
+        {
+            if (!BCrypt.Net.BCrypt.Verify(this.Password, model.PasswordHash))
+                return false;
+            
+            return true;
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Request/Create_BlogPost.cs b/exercise.wwwapi/DTO/Request/Create_BlogPost.cs
new file mode 100644
index 0000000..635b810
--- /dev/null
+++ b/exercise.wwwapi/DTO/Request/Create_BlogPost.cs
@@ -0,0 +1,28 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Security.Claims;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace exercise.wwwapi.DTO.Request
+{
+    public class Create_BlogPost : DTO_Request_create<BlogPost>
+    {
+        public string Text { get; set; }
+
+        public override BlogPost CreateAndReturnNewInstance(ClaimsPrincipal user,params object[] pathargs)
+        {
+            return new BlogPost
+            {
+                AuthorId = int.Parse(user.FindFirst(ClaimTypes.Sid).Value),
+                Text = this.Text
+            };
+        }
+
+        protected override Func<IQueryable<BlogPost>, IQueryable<BlogPost>> GetEntryWithIncludes(BlogPost createdEntity, params object[] id)
+        {
+            return x => x.Where(x => x.Id == createdEntity.Id).Include(x => x.User).Include(x => x.Comments);
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Request/Create_BlogPostComment.cs b/exercise.wwwapi/DTO/Request/Create_BlogPostComment.cs
new file mode 100644
index 0000000..e1ad908
--- /dev/null
+++ b/exercise.wwwapi/DTO/Request/Create_BlogPostComment.cs
@@ -0,0 +1,42 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Security.Claims;
+using System.Text.Json.Serialization;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace exercise.wwwapi.DTO.Request
+{
+    public class Create_BlogPostComment : DTO_Request_create<Comment>, IDTO_Defines_Include<Comment>
+    {
+        [JsonIgnore]
+        public int BlogPostId { get; set; }
+        public string Text { get; set; }
+
+        public static Func<IQueryable<Comment>, IQueryable<Comment>> _includeData()
+        {
+            return x => x.Include(x => x.User);
+        }
+
+        public override Comment CreateAndReturnNewInstance(ClaimsPrincipal user, params object[] pathargs)
+        {
+            return new Comment
+            {
+                UserId = int.Parse(user.FindFirst(ClaimTypes.Sid).Value),
+                BlogPostId = (int)pathargs[0],
+                Text = this.Text
+            };
+        }
+
+        protected override bool CheckConditionForValidCreate(ClaimsPrincipal user, Comment model, params object[] pathargs)
+        {
+            return model.UserId == int.Parse(user.FindFirst(ClaimTypes.Sid).Value); 
+        }
+
+        protected override Func<IQueryable<Comment>, IQueryable<Comment>> GetEntryWithIncludes(Comment createdEntity, params object[] id)
+        {
+            return x => x.Where(x => x.Id == createdEntity.Id).Include(x => x.User).Include(x => x.BlogPost);
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Request/Create_Following.cs b/exercise.wwwapi/DTO/Request/Create_Following.cs
new file mode 100644
index 0000000..f84fbdf
--- /dev/null
+++ b/exercise.wwwapi/DTO/Request/Create_Following.cs
@@ -0,0 +1,36 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Security.Claims;
+using System.Text.Json.Serialization;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+
+namespace exercise.wwwapi.DTO.Request
+{
+    public class Create_Following : DTO_Request_create<UserFollows>
+    {
+        [JsonIgnore]
+        public int FollowerId{ get; set; }
+        [JsonIgnore]
+        public int FollowingId{ get; set; }
+
+        public override UserFollows CreateAndReturnNewInstance(ClaimsPrincipal user, params object[] pathargs)
+        {
+            return new UserFollows
+            {
+                //FollowerId = int.Parse(user.FindFirst(ClaimTypes.Sid).Value), // better but does not align with criteria...
+                FollowerId = (int)pathargs[0],
+                FollowingsId = (int)pathargs[1]
+            };
+        }
+        protected override bool CheckConditionForValidCreate(ClaimsPrincipal user, UserFollows createdModel, params object[] pathargs)
+        {
+            return int.Parse(user.Claims.First().Value) == createdModel.FollowerId;
+        }
+
+        protected override Func<IQueryable<UserFollows>, IQueryable<UserFollows>> GetEntryWithIncludes(UserFollows createdEntity, params object[] id)
+        {
+            return x => x.Where(x => x.FollowerId == createdEntity.FollowerId && x.FollowingsId == createdEntity.FollowingsId);
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Request/Create_User.cs b/exercise.wwwapi/DTO/Request/Create_User.cs
new file mode 100644
index 0000000..658fa58
--- /dev/null
+++ b/exercise.wwwapi/DTO/Request/Create_User.cs
@@ -0,0 +1,31 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Security.Claims;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+
+namespace exercise.wwwapi.DTO.Request
+{
+    public class Create_User : DTO_Request_create<User>
+    {
+        public string Username { get; set; }
+        public string Password { get; set; }
+        public string Email { get; set; }
+
+        public override User CreateAndReturnNewInstance(ClaimsPrincipal user, params object[] pathargs)
+        {
+            return new User
+            {
+                Username = this.Username,
+                PasswordHash = BCrypt.Net.BCrypt.HashPassword(this.Password),
+                Email = this.Email,
+                Role  = "User"
+            };
+        }
+
+        protected override Func<IQueryable<User>, IQueryable<User>> GetEntryWithIncludes(User createdEntity, params object[] id)
+        {
+            return x => x.Where(x => x.Id == createdEntity.Id);
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Request/Remove_Following.cs b/exercise.wwwapi/DTO/Request/Remove_Following.cs
new file mode 100644
index 0000000..da6ac2b
--- /dev/null
+++ b/exercise.wwwapi/DTO/Request/Remove_Following.cs
@@ -0,0 +1,29 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Security.Claims;
+using System.Text.Json.Serialization;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+
+namespace exercise.wwwapi.DTO.Request
+{
+    public class Delete_Following : DTO_Request_delete<UserFollows>
+    {
+        [JsonIgnore]
+        public int FollowerId{ get; set; }
+        [JsonIgnore]
+        public int FollowingId{ get; set; }
+
+
+        protected override Func<IQueryable<UserFollows>, IQueryable<UserFollows>> getId(params object[] id)
+        {
+            return x => x.Where(x => x.FollowerId == (int)id[0] && x.FollowingsId == (int)id[1]);
+        }
+
+        protected override bool VerifRightsToDelete(ClaimsPrincipal user, UserFollows fetchedModel)
+        {
+            return int.Parse(user.FindFirst(ClaimTypes.Sid).Value) == fetchedModel.FollowerId
+                || user.IsInRole("Administrator"); 
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Request/Update_BlogPost.cs b/exercise.wwwapi/DTO/Request/Update_BlogPost.cs
new file mode 100644
index 0000000..251f226
--- /dev/null
+++ b/exercise.wwwapi/DTO/Request/Update_BlogPost.cs
@@ -0,0 +1,36 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Security.Claims;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Models;
+
+namespace exercise.wwwapi.DTO.Request
+{
+    public class Update_BlogPost : DTO_Request_update<BlogPost>
+    {
+        public string? Text { get; set; }
+
+        protected override Func<IQueryable<BlogPost>, IQueryable<BlogPost>> getId(params object[] id)
+        {
+            return x => x.Where(x => x.Id == (int)id[0]);
+        }
+
+        protected override BlogPost CreateAndReturnUpdatedInstance(BlogPost originalModelData)
+        {
+            return new BlogPost
+            {
+                Id = originalModelData.Id,
+                AuthorId = originalModelData.AuthorId,
+                Text = this.Text ?? originalModelData.Text,
+            };
+        }
+
+        protected override bool VerifRightsToUpdate(ClaimsPrincipal user, BlogPost fetchedModel)
+        {
+
+            return
+                int.Parse(user.FindFirst(ClaimTypes.Sid)!.Value) == fetchedModel.AuthorId
+                || user.IsInRole("Administrator"); 
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Response/Get_BlogPost.cs b/exercise.wwwapi/DTO/Response/Get_BlogPost.cs
new file mode 100644
index 0000000..4850032
--- /dev/null
+++ b/exercise.wwwapi/DTO/Response/Get_BlogPost.cs
@@ -0,0 +1,20 @@
+using api_cinema_challenge.DTO.Interfaces;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Identity;
+
+namespace exercise.wwwapi.DTO.Response
+{
+    public class Get_BlogPost : DTO_Response<Get_BlogPost, BlogPost>
+    {
+        public int Id { get; set; }
+        public int AuthorId { get; set; }
+        public string Text { get; set; }
+
+        protected override void _Initialize(BlogPost model)
+        {
+            Id = model.Id;
+            AuthorId = model.AuthorId;
+            Text = model.Text;
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Response/Get_BlogPostWithComments.cs b/exercise.wwwapi/DTO/Response/Get_BlogPostWithComments.cs
new file mode 100644
index 0000000..0394cb2
--- /dev/null
+++ b/exercise.wwwapi/DTO/Response/Get_BlogPostWithComments.cs
@@ -0,0 +1,29 @@
+using api_cinema_challenge.DTO.Interfaces;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+
+namespace exercise.wwwapi.DTO.Response
+{
+    public class Get_BlogPostWithComments : DTO_Response<Get_BlogPostWithComments, BlogPost>, IDTO_Defines_Include<BlogPost>
+    {
+        public int Id { get; set; }
+        public int AuthorId { get; set; }
+        public string Text { get; set; }
+        public List<Get_Comment> Comments { get; set; }
+
+        public static Func<IQueryable<BlogPost>, IQueryable<BlogPost>> _includeData()
+        {
+            return x => x.Include(x => x.Comments).ThenInclude(x => x.User);
+        }
+
+        protected override void _Initialize(BlogPost model)
+        {
+            Id = model.Id;
+            AuthorId = model.AuthorId;
+            Text = model.Text;
+            Comments = Get_Comment.Gets(model.Comments).ToList();
+        }
+
+    }
+}
diff --git a/exercise.wwwapi/DTO/Response/Get_Comment.cs b/exercise.wwwapi/DTO/Response/Get_Comment.cs
new file mode 100644
index 0000000..ce16a36
--- /dev/null
+++ b/exercise.wwwapi/DTO/Response/Get_Comment.cs
@@ -0,0 +1,18 @@
+using api_cinema_challenge.DTO.Interfaces;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Identity;
+
+namespace exercise.wwwapi.DTO.Response
+{
+    public class Get_Comment : DTO_Response<Get_Comment, Comment>
+    {
+        public string poster_name { get; set; }
+        public string Text { get; set; }
+
+        protected override void _Initialize(Comment model)
+        {
+            poster_name = model.User.Username;
+            Text = model.Text;
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Response/Get_Follows.cs b/exercise.wwwapi/DTO/Response/Get_Follows.cs
new file mode 100644
index 0000000..ac0775b
--- /dev/null
+++ b/exercise.wwwapi/DTO/Response/Get_Follows.cs
@@ -0,0 +1,21 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using api_cinema_challenge.DTO.Interfaces;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Identity;
+
+namespace exercise.wwwapi.DTO.Response
+{
+    public class Get_Follows : DTO_Response<Get_Follows, UserFollows>
+    {
+        public int FollowerId { get; set; }
+        public int FollowingsId { get; set; }
+
+        protected override void _Initialize(UserFollows model)
+        {
+            FollowerId = model.FollowerId;
+            FollowingsId = model.FollowingsId;
+
+
+        }
+    }
+}
diff --git a/exercise.wwwapi/DTO/Response/Get_User.cs b/exercise.wwwapi/DTO/Response/Get_User.cs
new file mode 100644
index 0000000..277ea55
--- /dev/null
+++ b/exercise.wwwapi/DTO/Response/Get_User.cs
@@ -0,0 +1,23 @@
+using api_cinema_challenge.DTO.Interfaces;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Identity;
+
+namespace exercise.wwwapi.DTO.Response
+{
+    public class Get_User : DTO_Response<Get_User, User>
+    {
+        public int Id { get; set; }
+        public string Username { get; set; }
+        public string PasswordHash { get; set; }
+        public string Email { get; set; }
+
+        protected override void _Initialize(User model)
+        {
+            Id = model.Id;
+            Username = model.Username;
+            PasswordHash = model.PasswordHash;
+            Email = model.Email;
+
+        }
+    }
+}
diff --git a/exercise.wwwapi/Data/DatabaseContext.cs b/exercise.wwwapi/Data/DatabaseContext.cs
new file mode 100644
index 0000000..9baf2bd
--- /dev/null
+++ b/exercise.wwwapi/Data/DatabaseContext.cs
@@ -0,0 +1,70 @@
+using System.Xml.Linq;
+using exercise.wwwapi.Configuration;
+using exercise.wwwapi.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace exercise.wwwapi.Data
+{
+    public class DatabaseContext : DbContext
+    {
+        private IConfigurationSettings _conf;
+        public DatabaseContext(DbContextOptions options, IConfigurationSettings conf) : base(options)
+        {
+            _conf = conf;
+            this.Database.EnsureCreated();
+        }
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<UserFollows>()
+                .HasKey(p => new { p.FollowingsId, p.FollowerId });
+                
+
+
+            modelBuilder.Entity<BlogPost>()
+                .HasOne(p => p.User)
+                .WithMany(p => p.BlogPosts)
+                .HasForeignKey(p => p.AuthorId);
+
+            modelBuilder.Entity<Comment>()
+                .HasOne(p => p.User)
+                .WithMany(p => p.Comments)
+                .HasForeignKey(p => p.UserId);
+
+            modelBuilder.Entity<Comment>()
+                .HasOne(p => p.BlogPost)
+                .WithMany(p => p.Comments)
+                .HasForeignKey(p => p.BlogPostId);
+
+            modelBuilder.Entity<UserFollows>()
+                .HasOne(p => p.Follower)
+                .WithMany(p => p.Followers)
+                .HasForeignKey(x => x.FollowerId);
+
+            modelBuilder.Entity<UserFollows>()
+                .HasOne(p => p.Following)
+                .WithMany(p => p.Followings)
+                .HasForeignKey(p => p.FollowingsId);
+
+            // Seed data
+            Seeder seeder = new Seeder();
+            modelBuilder.Entity<User>().
+                HasData(seeder.Users);
+            modelBuilder.Entity<BlogPost>().
+                HasData(seeder.BlogPosts);
+            modelBuilder.Entity<Comment>().
+                HasData(seeder.Comments);
+
+            base.OnModelCreating(modelBuilder);
+        }
+        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+        {
+            optionsBuilder.UseNpgsql(_conf.GetValue<string>("ConnectionStrings:DefaultConnectionString")!);
+            base.OnConfiguring(optionsBuilder);
+        }
+
+        public DbSet<User> Users { get; set; }
+        public DbSet<BlogPost> BlogPosts { get; set; }
+        public DbSet<UserFollows> UserFollows { get; set; }
+        public DbSet<Comment> Comments { get; set; }
+    }
+}
diff --git a/exercise.wwwapi/Data/Seeder.cs b/exercise.wwwapi/Data/Seeder.cs
new file mode 100644
index 0000000..29362d4
--- /dev/null
+++ b/exercise.wwwapi/Data/Seeder.cs
@@ -0,0 +1,56 @@
+using exercise.wwwapi.Models;
+
+namespace exercise.wwwapi.Data
+{
+    public class Seeder
+    {
+        public Seeder()
+        {
+            Users = new List<User>()
+            { 
+                new User{ Id = 1,
+                    Username = "Bob",
+                    Email = "Bob@bob.bob"     ,
+                    PasswordHash= BCrypt.Net.BCrypt.HashPassword("Tacos_with_pudding_and_burger_and_lassanga"),
+                    Role = "User"},
+                new User{ Id = 2,
+                    Username = "Flurp",
+                    Email = "flurp@bob.bob" ,
+                    PasswordHash= BCrypt.Net.BCrypt.HashPassword("Oaks123"),
+                    Role = "User"},
+                new User{ Id = 3,
+                    Username = "Glorp",
+                    Email = "glorp@bob.bob" ,
+                    PasswordHash= BCrypt.Net.BCrypt.HashPassword("glorps_password"), 
+                    Role = "User"},
+                new User{ Id = 4,
+                    Username = "admin",
+                    Email = "admin@admin.admin" ,
+                    PasswordHash= BCrypt.Net.BCrypt.HashPassword("admin"),
+                    Role = "Administrator"}
+            };
+            BlogPosts = new List<BlogPost>() { 
+                new BlogPost{ Id = 1, AuthorId = 1, Text = "Bob hungry today..."},
+                new BlogPost{ Id = 2, AuthorId = 2, Text = "Flurp not want tree, flurp has better things to do..."},
+                new BlogPost{ Id = 3, AuthorId = 3, Text = "Where Glorp make password to use blog? Glorp got story to tell. Help"},
+                new BlogPost{ Id = 4, AuthorId = 2, Text = "Ha Ha, Glorp don't know REST"},
+                new BlogPost{ Id = 5, AuthorId = 3, Text = "Glorp ate rock once, Glorp hurt teeth"},
+                new BlogPost{ Id = 6, AuthorId = 1, Text = "Maybe will try rock today, still hungry... "},
+            };
+
+            Comments = new List<Comment>() { 
+                new Comment{ Id=1, BlogPostId=6, UserId=3,  Text = "No... Read my post. Glorp hurt tooth"},
+                new Comment{ Id=2, BlogPostId=6, UserId=2,  Text = "Do it!"},
+                new Comment{ Id=3, BlogPostId=6, UserId=3,  Text = "How do I login? need to tell Bob not to eat rock..."},
+                new Comment{ Id=4, BlogPostId=5, UserId=1,  Text = "But was it a smooth or a jagged rock?"},
+                new Comment{ Id=5, BlogPostId=5, UserId=3,  Text = "glorps_password"},
+                new Comment{ Id=6, BlogPostId=5, UserId=3,  Text = "How do I remove?"},
+                new Comment{ Id=7, BlogPostId=5, UserId=3,  Text = "loook at me, i'm dumb glorp. I eat rocks. haha. I am so stopid"},
+                new Comment{ Id=8, BlogPostId=5, UserId=3,  Text = "I DID NOT DO THAT"},
+             };
+        }
+        public List<BlogPost> BlogPosts { get; set; }
+        public List<User> Users { get; set; }
+        public List<Comment> Comments { get; set; }
+    }
+}
diff --git a/exercise.wwwapi/Endpoints/AuthEndpoints.cs b/exercise.wwwapi/Endpoints/AuthEndpoints.cs
new file mode 100644
index 0000000..51234b0
--- /dev/null
+++ b/exercise.wwwapi/Endpoints/AuthEndpoints.cs
@@ -0,0 +1,51 @@
+
+using System.Security.Claims;
+using api_cinema_challenge.DTO;
+using api_cinema_challenge.DTO.Interfaces;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Configuration;
+using exercise.wwwapi.DTO.Request;
+using exercise.wwwapi.DTO.Response;
+using exercise.wwwapi.Models;
+using exercise.wwwapi.Payload;
+using Microsoft.AspNetCore.Http.HttpResults;
+
+namespace exercise.wwwapi.Endpoints
+{
+    public static class AuthEndpoints
+    {
+        public static void ConfigureAuthEndpoints(this WebApplication app)
+        {
+            var usergroup = app.MapGroup("auth");
+            usergroup.MapPost("/register", CreateUser);
+            usergroup.MapPost("/login", LoginUser);
+        }
+
+        private static async Task<IResult> LoginUser(HttpContext context, IRepository<User> repo,  IConfigurationSettings conf,Auth_Login_User dto)
+        {
+            try
+            {
+                await Auth_Login_User.authenticate(dto, repo, conf);
+                return TypedResults.Ok(Auth_Login_User.toPayloadAuth(dto));
+            }
+            catch (HttpRequestException ex)
+            {
+                return Fail.Payload(ex);
+            }
+        }
+
+        private static async Task<IResult> CreateUser(HttpContext context, IRepository<User> repo, ClaimsPrincipal user,Create_User dto)
+        {
+            if (await repo.GetEntry(x => x.Where(x => x.Username == dto.Username)) != null) return Fail.Payload("user already existed with that name", TypedResults.Conflict);
+            try
+            {
+                User createduser = await dto.Create(repo, user);
+                return TypedResults.Ok(Get_User.toPayload(createduser));
+            }
+            catch (HttpRequestException ex)
+            {
+                return Fail.Payload(ex);
+            }
+        }
+    }
+}
diff --git a/exercise.wwwapi/Endpoints/BlogEndpoints.cs b/exercise.wwwapi/Endpoints/BlogEndpoints.cs
new file mode 100644
index 0000000..94641e4
--- /dev/null
+++ b/exercise.wwwapi/Endpoints/BlogEndpoints.cs
@@ -0,0 +1,83 @@
+using wwwapi.Extensions;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Configuration;
+using exercise.wwwapi.DTO.Request;
+using exercise.wwwapi.DTO.Response;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Builder;
+using System.Security.Claims;
+using System.Net;
+using exercise.wwwapi.Payload;
+
+namespace exercise.wwwapi.Endpoints
+{
+    public static class BlogEndpoints
+    {
+        public static void ConfigureBlogEndpoints(this WebApplication app)
+        {
+            var usergroup = app.MapGroup("/blogposts");
+            usergroup.MapPost("/", CreatePost);
+            usergroup.MapPost("/{id}/comment", CreatePostComment);
+            usergroup.MapPut("/{id}", EditPost);
+            usergroup.MapGet("/", GetAllPosts);
+            usergroup.MapGet("withcomments/", GetAllUsersPosts_withComments);
+        }
+
+        [Authorize]
+        private static async Task<IResult> EditPost(HttpContext context, IRepository<BlogPost> repo, Update_BlogPost dto, ClaimsPrincipal user, int id )
+        {
+            try
+            {
+                var updated = await dto.Update(repo, user, id);
+                return TypedResults.Created(context.Get_endpointUrl<int>(id),Get_BlogPost.toPayload(updated));
+            }
+            catch (HttpRequestException ex)
+            {
+                return Fail.Payload(ex);
+            }
+        }
+        [Authorize]
+        private static async Task<IResult> CreatePostComment(HttpContext context, IRepository<Comment> repo, Create_BlogPostComment dto, ClaimsPrincipal user, int id )
+        {
+            try
+            {
+                var updated = await dto.Create(repo, user, id);
+                return TypedResults.Created(context.Get_endpointUrl<int>(id), Get_Comment.toPayload(updated));
+            }
+            catch (HttpRequestException ex)
+            {
+                return Fail.Payload(ex);
+            }
+        }
+
+        [Authorize]
+        private static async Task<IResult> GetAllPosts(HttpContext context, IRepository<BlogPost> repo)
+        {
+            
+            return TypedResults.Ok(await Get_BlogPost.toPayload(repo));
+        }
+
+        [Authorize]
+        private static async Task<IResult> GetAllUsersPosts_withComments(HttpContext context, IRepository<BlogPost> repo)
+        {
+
+            return TypedResults.Ok(await Get_BlogPostWithComments.toPayload(repo));
+        }
+
+        [Authorize]
+        private static async Task<IResult> CreatePost(HttpContext context, IRepository<BlogPost> repo, ClaimsPrincipal user, Create_BlogPost dto)
+        {
+            try
+            {
+                BlogPost post = await dto.Create(repo, user);
+                return TypedResults.Created(context.Get_endpointUrl<int>(post.Id), Get_BlogPost.toPayload(post));
+            }
+            catch (HttpRequestException ex)
+            {
+                return Fail.Payload(ex);
+            }
+
+        }
+    }
+}
diff --git a/exercise.wwwapi/Endpoints/FollowEndpoints.cs b/exercise.wwwapi/Endpoints/FollowEndpoints.cs
new file mode 100644
index 0000000..5f7e27a
--- /dev/null
+++ b/exercise.wwwapi/Endpoints/FollowEndpoints.cs
@@ -0,0 +1,71 @@
+using wwwapi.Extensions;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Configuration;
+using exercise.wwwapi.DTO.Request;
+using exercise.wwwapi.DTO.Response;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Builder;
+using System.Security.Claims;
+using System.Net;
+using Microsoft.EntityFrameworkCore;
+using exercise.wwwapi.Payload;
+
+namespace exercise.wwwapi.Endpoints
+{
+    public static class FollowEndpoints
+    {
+        public static void ConfigureFollowEndpoints(this WebApplication app)
+        {
+            var usergroup = app.MapGroup("/");
+            usergroup.MapPost("user/{userId}/follows/{otherUserId}", CreateFollowing);
+            usergroup.MapPost("user/{userId}/unfollows/{otherUserId}", RemoveFollowing);
+            usergroup.MapGet("viewall/{userId}", GetAllUsersPosts);
+        }
+
+        [Authorize]
+        private static async Task<IResult> GetAllUsersPosts(HttpContext context, IRepository<BlogPost> repo, IRepository<UserFollows> uf_repo, IRepository<User> user_repo, ClaimsPrincipal user, int userId)
+        {
+            // Prohibit other users from seeing who anothe user follows...
+            if (int.Parse(user.FindFirst(ClaimTypes.Sid).Value) != userId) return Fail.Payload("Unauthorized access denied", HttpStatusCode.Unauthorized);
+
+            return TypedResults.Ok(
+                await Get_BlogPost.toPayload(
+                    uf_repo,
+                    x => x.Where(x => x.FollowerId == userId)
+                             .Include(x => x.Following)
+                             .ThenInclude(x => x.BlogPosts),
+                    x => x.SelectMany(x => x.Following.BlogPosts)
+                    ));
+        }
+
+        [Authorize]
+        private static async Task<IResult> CreateFollowing(HttpContext context, IRepository<UserFollows> repo, ClaimsPrincipal user, Create_Following dto, int userId, int otherUserId)
+        {
+            try
+            {
+                UserFollows follow = await dto.Create(repo, user, userId, otherUserId);
+                return TypedResults.Created(context.Get_endpointUrl<int>(follow.FollowingsId), Get_Follows.toPayload(follow));
+            }
+            catch (HttpRequestException ex)
+            {
+                return Fail.Payload(ex);
+            }
+
+        }
+        [Authorize]
+        private static async Task<IResult> RemoveFollowing(HttpContext context, IRepository<UserFollows> repo, ClaimsPrincipal user, Delete_Following dto, int userId, int otherUserId)
+        {
+            try
+            {
+                UserFollows follow = await dto.Delete(repo, user, userId, otherUserId);
+                return TypedResults.Ok(Get_Follows.toPayload(follow));
+            }
+            catch (HttpRequestException ex)
+            {
+                return Fail.Payload(ex);
+            }
+        }
+
+    }
+}
diff --git a/exercise.wwwapi/Extensions/Http_context_extension.cs b/exercise.wwwapi/Extensions/Http_context_extension.cs
new file mode 100644
index 0000000..591baca
--- /dev/null
+++ b/exercise.wwwapi/Extensions/Http_context_extension.cs
@@ -0,0 +1,13 @@
+namespace wwwapi.Extensions
+{
+    public static class Http_context_extension
+    {
+        public static string Get_endpointUrl<T>(this HttpContext context, T indexVal)
+        {
+            string schemeType = context.Request.Scheme;
+            string local = context.Request.Host.ToUriComponent();
+            string path = context.Request.Path;
+            return string.Format($"{schemeType}://{local}{path}/{{0}}", indexVal);
+        }
+    }
+}
diff --git a/exercise.wwwapi/Models/BlogPost.cs b/exercise.wwwapi/Models/BlogPost.cs
new file mode 100644
index 0000000..a1f5f98
--- /dev/null
+++ b/exercise.wwwapi/Models/BlogPost.cs
@@ -0,0 +1,21 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using api_cinema_challenge.Models.Interfaces;
+
+namespace exercise.wwwapi.Models
+{
+    [Table("blog_posts")]
+    public class BlogPost :ICustomModel
+    {
+        [Key, Column("id")]
+        public int Id { get; set; }
+        [Column("user_id")]
+        public int AuthorId {  get; set; }
+        [Column("text")]
+        public string Text {  get; set; }
+
+        // Navigation properties 
+        public User User { get; set; }
+        public List<Comment> Comments { get; set; }
+    }
+}
diff --git a/exercise.wwwapi/Models/Comment.cs b/exercise.wwwapi/Models/Comment.cs
new file mode 100644
index 0000000..3354cf2
--- /dev/null
+++ b/exercise.wwwapi/Models/Comment.cs
@@ -0,0 +1,23 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using api_cinema_challenge.Models.Interfaces;
+
+namespace exercise.wwwapi.Models
+{
+    [Table("comments")]
+    public class Comment : ICustomModel
+    {
+        [Key,Column("id")]
+        public int Id { get; set; }
+        [Column("blog_post_id")]
+        public int BlogPostId { get; set; }
+        [Column("user_id")]
+        public int UserId { get; set; }
+        [Column("text")]
+        public string Text { get; set; }
+
+        // Navigation properties 
+        public BlogPost BlogPost { get; set; }
+        public User User { get; set; }
+    }
+}
diff --git a/exercise.wwwapi/Models/Interfaces/ICustomModel.cs b/exercise.wwwapi/Models/Interfaces/ICustomModel.cs
new file mode 100644
index 0000000..69d24b8
--- /dev/null
+++ b/exercise.wwwapi/Models/Interfaces/ICustomModel.cs
@@ -0,0 +1,9 @@
+namespace api_cinema_challenge.Models.Interfaces
+{
+    /// <summary>
+    /// Dummy interface all Models must implement in order to improve typesafety in the generic abstract Response and Request classess
+    /// </summary>
+    public interface ICustomModel
+    {
+    }
+}
diff --git a/exercise.wwwapi/Models/User.cs b/exercise.wwwapi/Models/User.cs
new file mode 100644
index 0000000..148021a
--- /dev/null
+++ b/exercise.wwwapi/Models/User.cs
@@ -0,0 +1,26 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using api_cinema_challenge.Models.Interfaces;
+
+namespace exercise.wwwapi.Models
+{
+    [Table("users")]
+    public class User : ICustomModel
+    {
+        [Column("id")]
+        public int Id { get; set; }
+        [Column("username")]
+        public string Username { get; set; }
+        [Column("passwordhash")]
+        public string PasswordHash { get; set; }
+        [Column("email")]
+        public string Email { get; set; }
+        [Column("role")]
+        public string Role { get; set; }
+
+        // Navigation properties 
+        public List<BlogPost> BlogPosts { get; set; }
+        public List<UserFollows> Followers{ get; set; }
+        public List<UserFollows> Followings { get; set; }
+        public List<Comment> Comments { get; set; }
+    }
+}
diff --git a/exercise.wwwapi/Models/UserFollows.cs b/exercise.wwwapi/Models/UserFollows.cs
new file mode 100644
index 0000000..b70119a
--- /dev/null
+++ b/exercise.wwwapi/Models/UserFollows.cs
@@ -0,0 +1,18 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using api_cinema_challenge.Models.Interfaces;
+
+namespace exercise.wwwapi.Models
+{
+    [Table("user_follows")]
+    public class UserFollows : ICustomModel
+    {
+        [Column("user_who_follows_id")]
+        public int FollowerId { get; set; }
+        [Column("user_to_follow_id")]
+        public int FollowingsId { get; set; }
+
+        // Navigation properties 
+        public User Follower { get; set; }
+        public User Following { get; set; }
+    }
+}
diff --git a/exercise.wwwapi/Payload/Fail.cs b/exercise.wwwapi/Payload/Fail.cs
new file mode 100644
index 0000000..e50f284
--- /dev/null
+++ b/exercise.wwwapi/Payload/Fail.cs
@@ -0,0 +1,55 @@
+using System.Net;
+using Microsoft.AspNetCore.Http.HttpResults;
+
+namespace exercise.wwwapi.Payload
+{
+    /// <summary>
+    ///  This is a payload helper to make it easier to return a payload based on bad requests...
+    /// </summary>
+    static public class Fail
+    {
+        static private Dictionary<HttpStatusCode, Func<object, IResult>> keys = new Dictionary<HttpStatusCode, Func<object, IResult>>()
+        {
+            {HttpStatusCode.NotFound  , TypedResults.NotFound},
+            {HttpStatusCode.BadRequest  , TypedResults.BadRequest},
+            {HttpStatusCode.Conflict , TypedResults.Conflict},
+            {HttpStatusCode.OK  , TypedResults.Ok},
+            {HttpStatusCode.UnprocessableContent  , TypedResults.UnprocessableEntity},
+            {HttpStatusCode.Unauthorized  , obj => TypedResults.Unauthorized()},
+            {HttpStatusCode.InternalServerError  ,  TypedResults.InternalServerError }
+        };
+
+        static public IResult Payload(string msg, Func<Payload<object, object>, IResult> func)
+        {
+            var failLoad = new Payload<object, object>();
+            failLoad.Status = "Failure";
+            failLoad.Data = new { Message = msg };
+
+            return func(failLoad);
+        }
+
+        static public IResult Payload(HttpRequestException ex)
+        {
+            var failLoad = new Payload<object, object>();
+            failLoad.Status = "Failure";
+            failLoad.Data = new { ex.Message };
+
+            if (keys.ContainsKey(ex.StatusCode.Value))
+                return keys[ex.StatusCode.Value].Invoke(failLoad);
+
+            return TypedResults.BadRequest(failLoad);
+        }
+
+        static public IResult Payload(string msg, HttpStatusCode code)
+        {
+            var failLoad = new Payload<object, object>();
+            failLoad.Status = "Failure";
+            failLoad.Data = new { Message = msg };
+
+            if (keys.ContainsKey(code))
+                return keys[code].Invoke(failLoad);
+
+            return TypedResults.BadRequest(failLoad);
+        }
+    }
+}
diff --git a/exercise.wwwapi/Payload/Payload.cs b/exercise.wwwapi/Payload/Payload.cs
new file mode 100644
index 0000000..cba276e
--- /dev/null
+++ b/exercise.wwwapi/Payload/Payload.cs
@@ -0,0 +1,14 @@
+using System.Text.Json.Serialization;
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace exercise.wwwapi.Payload
+{
+
+    public class Payload<T, Y>
+    {
+        public Payload() { }
+        public string Status { get; set; }
+        public T Data { get; set; }
+    }
+
+}
diff --git a/exercise.wwwapi/Program.cs b/exercise.wwwapi/Program.cs
index 47f22ef..be47644 100644
--- a/exercise.wwwapi/Program.cs
+++ b/exercise.wwwapi/Program.cs
@@ -1,9 +1,74 @@
+using System.Text;
+using api_cinema_challenge.Repository;
+using exercise.wwwapi.Configuration;
+using exercise.wwwapi.Data;
+using exercise.wwwapi.Endpoints;
+using exercise.wwwapi.Models;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.OpenApi.Models;
+
 var builder = WebApplication.CreateBuilder(args);
 
 // Add services to the container.
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
+builder.Services.AddSwaggerGen(setupActions =>
+    {
+        setupActions.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+        {
+            Description = "provide `Bearer <TOKEN>` to authenticate",
+            Name = "Authorization",
+            Type = SecuritySchemeType.ApiKey,
+            In = ParameterLocation.Header,
+            Scheme = "Bearer"
+        });
+        setupActions.AddSecurityRequirement(new OpenApiSecurityRequirement
+            {
+                {
+                    new OpenApiSecurityScheme
+                    {
+                        Reference = new OpenApiReference
+                        {
+                            Type = ReferenceType.SecurityScheme,
+                            Id = "Bearer"
+                        }
+                    },
+                    Array.Empty<string>()
+                }
+            });
+    });
+
+// AddScoped
+builder.Services.AddScoped<IConfigurationSettings, ConfigurationSettings>();
+builder.Services.AddScoped<IRepository<User>, Repository<User>>();
+builder.Services.AddScoped<IRepository<BlogPost>, Repository<BlogPost>>();
+builder.Services.AddScoped<IRepository<UserFollows>, Repository<UserFollows>>();
+builder.Services.AddScoped<IRepository<Comment>, Repository<Comment>>();
+builder.Services.AddDbContext<DatabaseContext>();
+
+var conf = new ConfigurationSettings();
+builder.Services.AddAuthentication(x =>
+    {
+        x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+        x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+        x.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
+    })
+    .AddJwtBearer( x =>
+    {
+        x.TokenValidationParameters = new TokenValidationParameters
+        {
+            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(conf.GetValue<string>("AppSettings:Token"))),
+            ValidateIssuer = false, 
+            ValidateAudience = false,
+            ValidateLifetime = false,
+            ValidateIssuerSigningKey = false
+        }; 
+    });
+
+builder.Services.AddAuthorization();
+
+builder.Services.AddCors();
 
 var app = builder.Build();
 
@@ -14,7 +79,18 @@
     app.UseSwaggerUI();
 }
 
+app.UseCors(x => x
+    .AllowAnyMethod()
+    .AllowAnyHeader()
+    .SetIsOriginAllowed(origin => true)
+    .AllowCredentials());
+
 app.UseHttpsRedirection();
+app.UseAuthentication();
+app.UseAuthorization();
 
+app.ConfigureBlogEndpoints();
+app.ConfigureAuthEndpoints();
+app.ConfigureFollowEndpoints();
 
 app.Run();
\ No newline at end of file
diff --git a/exercise.wwwapi/Repository/IRepository.cs b/exercise.wwwapi/Repository/IRepository.cs
new file mode 100644
index 0000000..92e82d2
--- /dev/null
+++ b/exercise.wwwapi/Repository/IRepository.cs
@@ -0,0 +1,16 @@
+using api_cinema_challenge.Models.Interfaces;
+using Microsoft.EntityFrameworkCore;
+
+namespace api_cinema_challenge.Repository
+{
+
+    public interface IRepository<T> where T : class 
+    {
+        Task<IEnumerable<T>> GetEntries(params Func<IQueryable<T>, IQueryable<T>>[] includes);
+        Task<T?> GetEntry(Func<IQueryable<T>, IQueryable<T>> id, params Func<IQueryable<T>, IQueryable<T>>[] expressions);
+        Task<T?> CreateEntry(T entry);
+        Task<T?> UpdateEntry(Func<IQueryable<T>, IQueryable<T>> id, T entry);
+        Task<T?> DeleteEntry(Func<IQueryable<T>, IQueryable<T>> id);
+    }
+    
+}
diff --git a/exercise.wwwapi/Repository/Repository.cs b/exercise.wwwapi/Repository/Repository.cs
new file mode 100644
index 0000000..effe995
--- /dev/null
+++ b/exercise.wwwapi/Repository/Repository.cs
@@ -0,0 +1,75 @@
+using api_cinema_challenge.Models.Interfaces;
+using exercise.wwwapi.Data;
+using Microsoft.EntityFrameworkCore;
+
+
+namespace api_cinema_challenge.Repository
+{
+    public class Repository<T> : IRepository<T> where T : class, new()
+    {
+        private DatabaseContext _databaseContext;
+        private DbSet<T> _table = null!;
+
+        public Repository(DatabaseContext db)
+        {
+            _databaseContext = db;
+            _table = db.Set<T>();
+        }
+
+        public async Task<IEnumerable<T>> GetEntries(params Func<IQueryable<T>, IQueryable<T>>[] includes)
+        {
+            IQueryable<T> q = _table.AsQueryable();
+
+            foreach (var inc in includes)
+                q = inc.Invoke(q);
+
+            return await q.ToArrayAsync();
+        }
+
+        public async Task<T?> GetEntry(Func<IQueryable<T>, IQueryable<T>> id, params Func<IQueryable<T>, IQueryable<T>>[] expressions)
+        {
+            IQueryable<T> q = _table.AsQueryable();
+
+            q = id.Invoke(q);
+            foreach (var ex in expressions)
+            {
+                q = ex.Invoke(q);
+            }
+
+            return await q.FirstOrDefaultAsync();
+        }
+        public async Task<T?> CreateEntry(T entry)
+        {
+            var a = await _table.AddAsync(entry);
+            await _databaseContext.SaveChangesAsync();
+            return entry;
+        }
+        public async Task<T?> UpdateEntry(Func<IQueryable<T>, IQueryable<T>> id, T entry)
+        {
+            IQueryable<T> q = _table.AsQueryable();
+            q = id.Invoke(q);
+            var foundEntry = await q.FirstOrDefaultAsync();
+
+            if (foundEntry == null) return null;
+            _table.Remove(foundEntry);
+            await _table.AddAsync(entry);            
+
+            await _databaseContext.SaveChangesAsync();
+            return await  id.Invoke(q).FirstAsync();
+        }
+        public async Task<T?> DeleteEntry(Func<IQueryable<T>, IQueryable<T>> id)
+        {
+            IQueryable<T> q = _table.AsQueryable();
+            q = id.Invoke(q);
+            var foundEntry = await q.FirstOrDefaultAsync();
+
+            if (foundEntry == null) return null;
+            _table.Remove(foundEntry);
+           await _databaseContext.SaveChangesAsync();
+            return foundEntry;
+        }
+
+
+
+    }
+}
diff --git a/exercise.wwwapi/appsettings.Development.example.json b/exercise.wwwapi/appsettings.Development.example.json
new file mode 100644
index 0000000..7a9d42d
--- /dev/null
+++ b/exercise.wwwapi/appsettings.Development.example.json
@@ -0,0 +1,15 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*",
+  "JwtTokenSettings": {
+    "ValidIssuer": "YourCompanyServer",
+    "ValidAudience": "YourProductAudience",
+    "SymmetricSecurityKey": "SOME_RANDOM_SECRET",
+    "JwtRegisteredClaimNamesSub": "SOME_RANDOM_CODE"
+  }
+}
diff --git a/exercise.wwwapi/exercise.wwwapi.csproj b/exercise.wwwapi/exercise.wwwapi.csproj
index 56929a8..73d2ca6 100644
--- a/exercise.wwwapi/exercise.wwwapi.csproj
+++ b/exercise.wwwapi/exercise.wwwapi.csproj
@@ -8,8 +8,23 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="bcrypt.net-core" Version="1.6.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.Jwtbearer" Version="9.0.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="9.0.1" />
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="9.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="NpgSql.EntityFrameworkCore.PostGreSql" Version="9.0.3" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="7.2.0" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.3.1" />
   </ItemGroup>
 
 </Project>