Restaurant Categories & Authentication

ProRestaurant/Classes/AppSettings.cs

+namespace ProRestaurant.Classes
+{
+    public class AppSettings
+    {
+        public string Secret { get; set; }
+    }
+}

ProRestaurant/Classes/Enums.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace ProRestaurant.Classes
+{
+    public enum SystemRole
+    {
+        SuperAdmin,
+        RestaurantAdmin,
+        RestaurantUser,        
+        Customer
+    }
+}

ProRestaurant/Classes/ImageFormatter.cs

+using System;
+using System.Drawing;
+using System.IO;
+
+namespace ProRestaurant.Classes
+{
+    public class ImageFormatter
+    {
+        public static string Base64ToImage(string binData, string path, string name)
+        {
+            string extention = ".jpg";
+            if (binData.StartsWith("data:image/gif;base64,"))
+            {
+                extention = ".gif";
+                binData = binData.Replace("data:image/gif;base64,", "");
+            }
+            if (binData.StartsWith("data:image/jpeg;base64,"))
+            {
+                extention = ".jpg";
+                binData = binData.Replace("data:image/jpeg;base64,", "");
+            }
+            if (binData.StartsWith("data:image/png;base64,"))
+            {
+                extention = ".png";
+                binData = binData.Replace("data:image/png;base64,", "");
+            }
+
+            if (!Directory.Exists(path))
+                Directory.CreateDirectory(path);
+
+            string filePath = string.Format(@"{0}\{1}{2}", path, name, extention);
+            File.WriteAllBytes(filePath, Convert.FromBase64String(binData));
+            return filePath;
+        }
+
+        public static string ImageToBase64(string Path)
+        {
+            if (File.Exists(Path))
+            {
+                using (Image image = Image.FromFile(Path))
+                {
+                    using (MemoryStream m = new MemoryStream())
+                    {
+                        image.Save(m, image.RawFormat);
+                        byte[] imageBytes = m.ToArray();
+
+                        string base64String = Convert.ToBase64String(imageBytes);
+
+                        if (Path.EndsWith(".jpg") || Path.EndsWith(".jpeg"))
+                            base64String = "data:image/jpeg;base64," + base64String;
+                        if (Path.EndsWith(".gif"))
+                            base64String = "data:image/gif;base64," + base64String;
+                        if (base64String.EndsWith(".png"))
+                            base64String = "data:image/png;base64," + base64String;
+
+                        return base64String;
+                    }
+                }
+            }
+            else
+                return "";
+        }
+    }
+}

ProRestaurant/Containers/RestaurantContainer.cs

+using ProRestaurant.Models.Restaurants;
+using System.Collections.Generic;
+
+namespace ProRestaurant.Containers
+{
+    public class RestaurantContainer : Restaurant
+    {
+        public string UserFirstName { get; set; }
+        public string UserSurname { get; set; }        
+        public string UserEmailAddress { get; set; }
+        public string UserPassword { get; set; }
+
+        public List<TradingHoursContainer> THours { get; set; }        
+        public string Result { get; set; }        
+    }
+
+    public class RestaurantCard
+    {
+        public int Id { get; set; }
+        public string Logo { get; set; }
+        public string Name { get; set; }
+        public string Suburb { get; set; }
+        public string SubText { get; set; }
+        public string DeliveryTime { get; set; }
+        public string DeliveryFee { get; set; }
+    }
+}

ProRestaurant/Containers/TradingHoursContainer.cs

+namespace ProRestaurant.Containers
+{
+    public class TradingHoursContainer
+    {
+        public string Description { get; set; }
+        public string From { get; set; }
+        public string To { get; set; }
+        public bool Closed { get; set; }
+        public bool Open24 { get; set; }
+    }
+}

ProRestaurant/Containers/UserContainer.cs

 
 namespace ProRestaurant.Containers
 {
-    public class UserContainer 
+    public class UserContainer : User
     {
-        public string ResultString { get; set; }
-        public User user { get; set; }
+        public string ResultString { get; set; }       
+    }
+
+    public class AuthenticationContiner
+    {        
+        public int ID { get; set; }
+        public string Name { get; set; }
+        public string Surname { get; set; }
+        public string EmailAddress { get; set; }
+        public string Password { get; set; }
+        public string Role { get; set; }
+        public string Result { get; set; }
+        public string Token { get; set; }
     }
 }

ProRestaurant/Controllers/Accounts/AuthenticationController.cs

+
+using Microsoft.AspNetCore.Mvc;
+using ProRestaurant.Containers;
+using ProRestaurant.Repository.Accounts;
+
+namespace ProRestaurant.Controllers.Accounts
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class AuthenticationController : ControllerBase
+    {
+        private IAuthenticateRepository repo;
+        public AuthenticationController(IAuthenticateRepository Repo)
+        {
+            repo = Repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(repo.GetAuthenticationContiner());
+        }       
+        
+        [HttpPost("authenticate")]
+        public IActionResult Authenticate([FromBody] AuthenticationContiner User)
+        {
+            var user = repo.Login(User);
+            if (user.Result != "Access Granted")
+                return BadRequest(new { message = user.Result });
+
+            return Ok(user);
+        }        
+    }
+}

ProRestaurant/Controllers/Accounts/RegistrationController.cs

+using Microsoft.AspNetCore.Mvc;
+using ProRestaurant.Containers;
+using ProRestaurant.Repository.Accounts;
+using System.Transactions;
+
+
+namespace ProRestaurant.Controllers.Accounts
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class RegistrationController : ControllerBase
+    {
+        private readonly IRegistrationRepository regRepository;
+
+        public RegistrationController(IRegistrationRepository regRepo)
+        {
+            regRepository = regRepo;
+        }               
+
+        [HttpGet("GetUserContainer")]
+        public IActionResult GetUserContainer()
+        {
+            var userContainer = regRepository.GetUserContainer();
+            return new OkObjectResult(userContainer);
+        }
+
+        [HttpGet("GetRestaurantContainer")]
+        public IActionResult GetRestaurantContainer()
+        {
+            var container = regRepository.GetRestaurantContainer();
+            return new OkObjectResult(container);
+        }        
+
+        [HttpPost("resgisterRestaurant")]
+        public IActionResult ResgisterRestaurant([FromBody] RestaurantContainer container)
+        {
+            using (var scope = new TransactionScope())
+            {
+                regRepository.RegisterRestaurant(container);
+                scope.Complete();
+                return new OkObjectResult(container);                
+            }
+        }
+
+        [HttpPost("resgisterUser")]
+        public IActionResult ResgisterUser([FromBody] UserContainer container)
+        {
+            using (var scope = new TransactionScope())
+            {
+                regRepository.RegisterUser(container);
+                scope.Complete();                
+                return new OkObjectResult(container);
+            }
+        }
+    }
+}

ProRestaurant/Controllers/Accounts/UserController.cs

-using Microsoft.AspNetCore.Mvc;
-using ProRestaurant.Models.Accounts;
-using ProRestaurant.Repository.Accounts;
-using System.Transactions;
-
-
-namespace ProRestaurant.Controllers.Accounts
-{
-    [Route("api/[controller]")]
-    [ApiController]
-    public class UserController : ControllerBase
-    {
-        private readonly IUserRepository userRepository;
-
-        public UserController(IUserRepository userRepo)
-        {
-            userRepository = userRepo;
-        }
-        
-        [HttpGet]
-        public IActionResult Get()
-        {
-            return new OkObjectResult(userRepository.GetUsers());
-        }
-        
-        [HttpGet("{id}")]
-        public IActionResult Get(int id)
-        {
-            var user = userRepository.GetUser(u => u.Id == id);
-            return new OkObjectResult(user);
-        }
-
-        [HttpGet("Login/{username}/{password}")]
-        public IActionResult Login(string username, string password)
-        {
-            return new OkObjectResult(userRepository.Login(username, password));
-        }
-        
-        [HttpPost]
-        public IActionResult Post([FromBody] User user)
-        {
-            using (var scope = new TransactionScope())
-            {
-                userRepository.Insert(user);
-                scope.Complete();
-                return CreatedAtAction(nameof(Get), new { id = user.Id }, user);
-            }
-        }
-        
-        [HttpPut]
-        public IActionResult Put([FromBody] User user)
-        {
-            if (user != null)
-            {
-                using (var scope = new TransactionScope())
-                {
-                    userRepository.Update(user);
-                    scope.Complete();
-                    return new OkResult();
-                }
-            }
-            return new NoContentResult();
-        }
-        
-        [HttpDelete("{id}")]
-        public IActionResult Delete(int id)
-        {
-            userRepository.Remove(userRepository.GetUser(u => u.Id == id));
-            return new OkResult();
-        }
-    }
-}

ProRestaurant/Controllers/Restaurants/IRestaurantCategory.cs

+namespace ProRestaurant.Controllers.Restaurants
+{
+    internal interface IRestaurantCategory
+    {
+    }
+}

ProRestaurant/Controllers/Restaurants/RestaurantCategoryController.cs

+using Microsoft.AspNetCore.Mvc;
+using ProRestaurant.Models.Restaurants;
+using ProRestaurant.Repository.Restaurants;
+using System.Transactions;
+
+namespace ProRestaurant.Controllers.Restaurants
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class RestaurantCategoryController : Controller
+    {
+        private readonly IRestaurantCategoryRepository repo; 
+
+        public RestaurantCategoryController(IRestaurantCategoryRepository Repo)
+        {
+            repo = Repo;
+        }
+
+        [HttpGet]
+        public IActionResult Get()
+        {
+            return new OkObjectResult(repo.Get());
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] RestaurantCategory category)
+        {
+            using (var scope = new TransactionScope())
+            {
+                repo.Insert(category);
+                scope.Complete();
+                return new OkObjectResult(category);
+            }
+        }
+
+        [HttpPut]
+        public IActionResult Put([FromBody] RestaurantCategory category)
+        {
+            if (category != null)
+            {
+                using (var scope = new TransactionScope())
+                {
+                    repo.Update(category);
+                    scope.Complete();
+                    return new OkResult();
+                }
+            }
+            return new NoContentResult();
+        }
+
+        [HttpDelete("{id}")]
+        public IActionResult Delete(int id)
+        {            
+            repo.Remove(id);
+            return new OkResult();
+        }
+    }
+}

ProRestaurant/Controllers/Restaurants/RestaurantController.cs

         [HttpGet]
         public IActionResult Get()
         {
-            return new OkObjectResult(repo.GetUsers());
+            return new OkObjectResult(repo.GetSearch());
         }
 
         [HttpGet("{id}")]
         {
             var restaurant = repo.GetRestaurant(u => u.Id == id);
             return new OkObjectResult(restaurant);
-        }
+        }        
 
         [HttpPost]
         public IActionResult Post([FromBody] Restaurant restaurant)

ProRestaurant/DBContexts/DBContext.cs

-using Microsoft.EntityFrameworkCore;
+using Microsoft.CodeAnalysis;
+using Microsoft.EntityFrameworkCore;
 using Npgsql;
 using ProRestaurant.Models;
 using ProRestaurant.Models.Accounts;
+using ProRestaurant.Models.Misc;
 using ProRestaurant.Models.Restaurants;
 using System.Data.SqlClient;
 using System.Linq;
         public DbSet<TradingHours> TradingHours { get; set; }
         public DbSet<MenuCategory> MenuCategories { get; set; }
         public DbSet<MenuItem> MenuItems { get; set; }
-        #endregion 
+        public DbSet<RestaurantUser> RestaurantUsers { get; set; }
+        public DbSet<RestaurantCategory> RestaurantCategories { get; set; }
+        #endregion
+
+        #region Misc
+        public DbSet<Locations> Locations { get; set; }
+        #endregion
 
         public override int SaveChanges()
         {
+            bool isBaseObject = false;
             foreach (var item in ChangeTracker
                                     .Entries()
                                     .Where(x => x.State == EntityState.Modified || x.State == EntityState.Added)
             {
                 if (item is BaseObject)
                 {
+                    isBaseObject = true;
                     (item as BaseObject).UpdateModified(string.Empty);
                 }
             }
-            UpdateSoftDeleteStatuses();
+            if (isBaseObject)
+                UpdateSoftDeleteStatuses();
+
             return base.SaveChanges();
         }
 
         private void UpdateSoftDeleteStatuses()
-        {
+        {            
             foreach (var entry in ChangeTracker.Entries())
-            {
+            {                
                 switch (entry.State)
                 {
                     case EntityState.Added:
             modelBuilder.Entity<DriverDetail>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
             modelBuilder.Entity<Restaurant>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
             modelBuilder.Entity<TradingHours>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<MenuCategory>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<MenuItem>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);
+            modelBuilder.Entity<RestaurantUser>().HasQueryFilter(m => EF.Property<bool>(m, "IsDeleted") == false);            
         }
 
         public int GetNextID(string tableName)

ProRestaurant/Migrations/20200526094220_initialCreate.Designer.cs → ProRestaurant/Migrations/20200608091919_ReInitDB.Designer.cs

 namespace ProRestaurant.Migrations
 {
     [DbContext(typeof(DBContext))]
-    [Migration("20200526094220_initialCreate")]
-    partial class initialCreate
+    [Migration("20200608091919_ReInitDB")]
+    partial class ReInitDB
     {
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
         {
 
                     b.Property<string>("Surname");
 
+                    b.Property<int>("SystemRole");
+
                     b.HasKey("Id");
 
                     b.ToTable("Users");
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDefault");
+
                     b.Property<bool>("IsDeleted");
 
                     b.Property<decimal>("Latitude");
                     b.ToTable("UserAddresses");
                 });
 
+            modelBuilder.Entity("ProRestaurant.Models.Misc.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ImageStore");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
             modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
                 {
                     b.Property<int>("Id")
 
                     b.Property<bool>("Chain");
 
+                    b.Property<string>("City");
+
+                    b.Property<string>("Country");
+
                     b.Property<DateTime>("Created");
 
                     b.Property<decimal>("DeliveryFee");
 
                     b.Property<decimal>("DeliveryRadius");
 
+                    b.Property<string>("GoogleMapUrl");
+
                     b.Property<bool>("IsDeleted");
 
-                    b.Property<string>("Location");
+                    b.Property<decimal>("Latitude");
 
                     b.Property<string>("Logo");
 
+                    b.Property<decimal>("Longitude");
+
                     b.Property<string>("MethodsOfPayment");
 
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("Name");
 
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("ShopNumber");
+
+                    b.Property<string>("ShoppingCentre");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("StreetNumber");
+
+                    b.Property<string>("Suburb");
+
                     b.HasKey("Id");
 
                     b.ToTable("Restaurants");
                 });
 
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RestaurantUsers");
+                });
+
             modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
                         .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
+                    b.Property<bool>("Closed");
+
                     b.Property<DateTime>("ClosingTime");
 
                     b.Property<DateTime>("Created");
             modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
                 {
                     b.HasOne("ProRestaurant.Models.Accounts.User", "User")
-                        .WithMany()
+                        .WithMany("Addresses")
                         .HasForeignKey("UserId")
                         .OnDelete(DeleteBehavior.Cascade);
                 });
                         .OnDelete(DeleteBehavior.Cascade);
                 });
 
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("Users")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
             modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
                 {
                     b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")

ProRestaurant/Migrations/20200526094220_initialCreate.cs → ProRestaurant/Migrations/20200608091919_ReInitDB.cs

 
 namespace ProRestaurant.Migrations
 {
-    public partial class initialCreate : Migration
+    public partial class ReInitDB : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)
         {
+            migrationBuilder.CreateTable(
+                name: "Locations",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
+                    ImageStore = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Locations", x => x.Id);
+                });
+
             migrationBuilder.CreateTable(
                 name: "Restaurants",
                 columns: table => new
                     ModifiedBy = table.Column<string>(nullable: true),
                     IsDeleted = table.Column<bool>(nullable: false),
                     Name = table.Column<string>(nullable: true),
-                    Location = table.Column<string>(nullable: true),
                     Logo = table.Column<string>(nullable: true),
                     Chain = table.Column<bool>(nullable: false),
                     DeliveryFee = table.Column<decimal>(nullable: false),
                     DeliveryRadius = table.Column<decimal>(nullable: false),
-                    MethodsOfPayment = table.Column<string>(nullable: true)
+                    MethodsOfPayment = table.Column<string>(nullable: true),
+                    ShoppingCentre = table.Column<string>(nullable: true),
+                    ShopNumber = table.Column<string>(nullable: true),
+                    GoogleMapUrl = table.Column<string>(nullable: true),
+                    Latitude = table.Column<decimal>(nullable: false),
+                    Longitude = table.Column<decimal>(nullable: false),
+                    StreetNumber = table.Column<string>(nullable: true),
+                    StreetName = table.Column<string>(nullable: true),
+                    Suburb = table.Column<string>(nullable: true),
+                    City = table.Column<string>(nullable: true),
+                    Provice = table.Column<string>(nullable: true),
+                    Country = table.Column<string>(nullable: true),
+                    PostalCode = table.Column<string>(nullable: true)
                 },
                 constraints: table =>
                 {
                     Password = table.Column<string>(nullable: true),
                     FirstName = table.Column<string>(nullable: true),
                     Surname = table.Column<string>(nullable: true),
-                    Cellphone = table.Column<string>(nullable: true)
+                    Cellphone = table.Column<string>(nullable: true),
+                    SystemRole = table.Column<int>(nullable: false)
                 },
                 constraints: table =>
                 {
                     RestaurantId = table.Column<int>(nullable: false),
                     Description = table.Column<string>(nullable: true),
                     OpeningTime = table.Column<DateTime>(nullable: false),
-                    ClosingTime = table.Column<DateTime>(nullable: false)
+                    ClosingTime = table.Column<DateTime>(nullable: false),
+                    Closed = table.Column<bool>(nullable: false)
                 },
                 constraints: table =>
                 {
                         onDelete: ReferentialAction.Cascade);
                 });
 
+            migrationBuilder.CreateTable(
+                name: "RestaurantUsers",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
+                    Created = table.Column<DateTime>(nullable: false),
+                    Modified = table.Column<DateTime>(nullable: false),
+                    ModifiedBy = table.Column<string>(nullable: true),
+                    IsDeleted = table.Column<bool>(nullable: false),
+                    UserId = table.Column<int>(nullable: false),
+                    RestaurantId = table.Column<int>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_RestaurantUsers", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_RestaurantUsers_Restaurants_RestaurantId",
+                        column: x => x.RestaurantId,
+                        principalTable: "Restaurants",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_RestaurantUsers_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
             migrationBuilder.CreateTable(
                 name: "UserAddresses",
                 columns: table => new
                     ModifiedBy = table.Column<string>(nullable: true),
                     IsDeleted = table.Column<bool>(nullable: false),
                     UserId = table.Column<int>(nullable: false),
+                    IsDefault = table.Column<bool>(nullable: false),
+                    GoogleMapUrl = table.Column<string>(nullable: true),
                     Latitude = table.Column<decimal>(nullable: false),
                     Longitude = table.Column<decimal>(nullable: false),
                     UnitNumber = table.Column<string>(nullable: true),
                 table: "MenuItems",
                 column: "RestaurantId");
 
+            migrationBuilder.CreateIndex(
+                name: "IX_RestaurantUsers_RestaurantId",
+                table: "RestaurantUsers",
+                column: "RestaurantId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RestaurantUsers_UserId",
+                table: "RestaurantUsers",
+                column: "UserId");
+
             migrationBuilder.CreateIndex(
                 name: "IX_TradingHours_RestaurantId",
                 table: "TradingHours",
             migrationBuilder.DropTable(
                 name: "DriverDetails");
 
+            migrationBuilder.DropTable(
+                name: "Locations");
+
             migrationBuilder.DropTable(
                 name: "MenuCategories");
 
             migrationBuilder.DropTable(
                 name: "MenuItems");
 
+            migrationBuilder.DropTable(
+                name: "RestaurantUsers");
+
             migrationBuilder.DropTable(
                 name: "TradingHours");
 

ProRestaurant/Migrations/20200608113150_001.Designer.cs

+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using ProRestaurant.DBContexts;
+
+namespace ProRestaurant.Migrations
+{
+    [DbContext(typeof(DBContext))]
+    [Migration("20200608113150_001")]
+    partial class _001
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.2.0-rtm-35687")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Photo");
+
+                    b.Property<string>("RegistrationNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("DriverDetails");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Cellphone");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("EmailAddress");
+
+                    b.Property<string>("FirstName");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Password");
+
+                    b.Property<string>("Surname");
+
+                    b.Property<int>("SystemRole");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("ComplexName");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDefault");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("SteetNumber");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("Suburb");
+
+                    b.Property<string>("UnitNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserAddresses");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Misc.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ImageStore");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("CategoryId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("Image");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<decimal>("Price");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuItems");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.Restaurant", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<bool>("Chain");
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<decimal>("DeliveryFee");
+
+                    b.Property<decimal>("DeliveryRadius");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<string>("Logo");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<string>("MethodsOfPayment");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("ShopNumber");
+
+                    b.Property<string>("ShoppingCentre");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("StreetNumber");
+
+                    b.Property<string>("Suburb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Restaurants");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RestaurantUsers");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<bool>("Closed");
+
+                    b.Property<DateTime>("ClosingTime");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<bool>("Opened24H");
+
+                    b.Property<DateTime>("OpeningTime");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("TradingHours");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithOne("DriverDetails")
+                        .HasForeignKey("ProRestaurant.Models.Accounts.DriverDetail", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany("Addresses")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("Users")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("TradingHours")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ProRestaurant/Migrations/20200608113150_001.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ProRestaurant.Migrations
+{
+    public partial class _001 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "Opened24H",
+                table: "TradingHours",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Opened24H",
+                table: "TradingHours");
+        }
+    }
+}

ProRestaurant/Migrations/20200608133845_002.Designer.cs

+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using ProRestaurant.DBContexts;
+
+namespace ProRestaurant.Migrations
+{
+    [DbContext(typeof(DBContext))]
+    [Migration("20200608133845_002")]
+    partial class _002
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.2.0-rtm-35687")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Photo");
+
+                    b.Property<string>("RegistrationNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("DriverDetails");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Cellphone");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("EmailAddress");
+
+                    b.Property<string>("FirstName");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Password");
+
+                    b.Property<string>("Surname");
+
+                    b.Property<int>("SystemRole");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("ComplexName");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDefault");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("SteetNumber");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("Suburb");
+
+                    b.Property<string>("UnitNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserAddresses");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Misc.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ImageStore");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("CategoryId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("Image");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<decimal>("Price");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuItems");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.Restaurant", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Categories");
+
+                    b.Property<bool>("Chain");
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<decimal>("DeliveryFee");
+
+                    b.Property<decimal>("DeliveryRadius");
+
+                    b.Property<string>("DeliveryTime");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<string>("Logo");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<string>("MethodsOfPayment");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("ShopNumber");
+
+                    b.Property<string>("ShoppingCentre");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("StreetNumber");
+
+                    b.Property<string>("Suburb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Restaurants");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Description");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RestaurantCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RestaurantUsers");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<bool>("Closed");
+
+                    b.Property<DateTime>("ClosingTime");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<bool>("Opened24H");
+
+                    b.Property<DateTime>("OpeningTime");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("TradingHours");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithOne("DriverDetails")
+                        .HasForeignKey("ProRestaurant.Models.Accounts.DriverDetail", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany("Addresses")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("Users")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("TradingHours")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ProRestaurant/Migrations/20200608133845_002.cs

+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ProRestaurant.Migrations
+{
+    public partial class _002 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Categories",
+                table: "Restaurants",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "DeliveryTime",
+                table: "Restaurants",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "RestaurantCategories",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
+                    Description = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_RestaurantCategories", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "RestaurantCategories");
+
+            migrationBuilder.DropColumn(
+                name: "Categories",
+                table: "Restaurants");
+
+            migrationBuilder.DropColumn(
+                name: "DeliveryTime",
+                table: "Restaurants");
+        }
+    }
+}

ProRestaurant/Migrations/20200608133952_003.Designer.cs

+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using ProRestaurant.DBContexts;
+
+namespace ProRestaurant.Migrations
+{
+    [DbContext(typeof(DBContext))]
+    [Migration("20200608133952_003")]
+    partial class _003
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.2.0-rtm-35687")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Photo");
+
+                    b.Property<string>("RegistrationNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("DriverDetails");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Cellphone");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("EmailAddress");
+
+                    b.Property<string>("FirstName");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Password");
+
+                    b.Property<string>("Surname");
+
+                    b.Property<int>("SystemRole");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("ComplexName");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDefault");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("SteetNumber");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("Suburb");
+
+                    b.Property<string>("UnitNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserAddresses");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Misc.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("ImageStore");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("CategoryId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("Image");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<decimal>("Price");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuItems");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.Restaurant", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Categories");
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<decimal>("DeliveryFee");
+
+                    b.Property<decimal>("DeliveryRadius");
+
+                    b.Property<string>("DeliveryTime");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<string>("Logo");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<string>("MethodsOfPayment");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("ShopNumber");
+
+                    b.Property<string>("ShoppingCentre");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("StreetNumber");
+
+                    b.Property<string>("Suburb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Restaurants");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Description");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RestaurantCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RestaurantUsers");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<bool>("Closed");
+
+                    b.Property<DateTime>("ClosingTime");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<bool>("Opened24H");
+
+                    b.Property<DateTime>("OpeningTime");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("TradingHours");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithOne("DriverDetails")
+                        .HasForeignKey("ProRestaurant.Models.Accounts.DriverDetail", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany("Addresses")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("Users")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("TradingHours")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ProRestaurant/Migrations/20200608133952_003.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ProRestaurant.Migrations
+{
+    public partial class _003 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Chain",
+                table: "Restaurants");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "Chain",
+                table: "Restaurants",
+                nullable: false,
+                defaultValue: false);
+        }
+    }
+}

ProRestaurant/Migrations/20200609191325_004.Designer.cs

+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using ProRestaurant.DBContexts;
+
+namespace ProRestaurant.Migrations
+{
+    [DbContext(typeof(DBContext))]
+    [Migration("20200609191325_004")]
+    partial class _004
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.2.0-rtm-35687")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128)
+                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Photo");
+
+                    b.Property<string>("RegistrationNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("DriverDetails");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Cellphone");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("EmailAddress");
+
+                    b.Property<string>("FirstName");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Password");
+
+                    b.Property<string>("Surname");
+
+                    b.Property<int>("SystemRole");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("ComplexName");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDefault");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("SteetNumber");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("Suburb");
+
+                    b.Property<string>("UnitNumber");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserAddresses");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Misc.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CategoryStore");
+
+                    b.Property<string>("ImageStore");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<int>("CategoryId");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("Image");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<decimal>("Price");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("MenuItems");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.Restaurant", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Categories");
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("Country");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<decimal>("DeliveryFee");
+
+                    b.Property<decimal>("DeliveryRadius");
+
+                    b.Property<string>("DeliveryTime");
+
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<decimal>("Latitude");
+
+                    b.Property<string>("Logo");
+
+                    b.Property<decimal>("Longitude");
+
+                    b.Property<string>("MethodsOfPayment");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("ShopNumber");
+
+                    b.Property<string>("ShoppingCentre");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("StreetNumber");
+
+                    b.Property<string>("Suburb");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Restaurants");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("Image");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RestaurantCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RestaurantUsers");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<bool>("Closed");
+
+                    b.Property<DateTime>("ClosingTime");
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<string>("Description");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<bool>("Opened24H");
+
+                    b.Property<DateTime>("OpeningTime");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.ToTable("TradingHours");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.DriverDetail", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithOne("DriverDetails")
+                        .HasForeignKey("ProRestaurant.Models.Accounts.DriverDetail", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany("Addresses")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuItem", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany()
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("Users")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("TradingHours")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

ProRestaurant/Migrations/20200609191325_004.cs

+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace ProRestaurant.Migrations
+{
+    public partial class _004 : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Image",
+                table: "RestaurantCategories",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "CategoryStore",
+                table: "Locations",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Image",
+                table: "RestaurantCategories");
+
+            migrationBuilder.DropColumn(
+                name: "CategoryStore",
+                table: "Locations");
+        }
+    }
+}

ProRestaurant/Migrations/DBContextModelSnapshot.cs

 
                     b.Property<string>("Surname");
 
+                    b.Property<int>("SystemRole");
+
                     b.HasKey("Id");
 
                     b.ToTable("Users");
 
                     b.Property<DateTime>("Created");
 
+                    b.Property<string>("GoogleMapUrl");
+
+                    b.Property<bool>("IsDefault");
+
                     b.Property<bool>("IsDeleted");
 
                     b.Property<decimal>("Latitude");
                     b.ToTable("UserAddresses");
                 });
 
+            modelBuilder.Entity("ProRestaurant.Models.Misc.Locations", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("CategoryStore");
+
+                    b.Property<string>("ImageStore");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
             modelBuilder.Entity("ProRestaurant.Models.Restaurants.MenuCategory", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
                         .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
-                    b.Property<bool>("Chain");
+                    b.Property<string>("Categories");
+
+                    b.Property<string>("City");
+
+                    b.Property<string>("Country");
 
                     b.Property<DateTime>("Created");
 
 
                     b.Property<decimal>("DeliveryRadius");
 
+                    b.Property<string>("DeliveryTime");
+
+                    b.Property<string>("GoogleMapUrl");
+
                     b.Property<bool>("IsDeleted");
 
-                    b.Property<string>("Location");
+                    b.Property<decimal>("Latitude");
 
                     b.Property<string>("Logo");
 
+                    b.Property<decimal>("Longitude");
+
                     b.Property<string>("MethodsOfPayment");
 
                     b.Property<DateTime>("Modified");
 
                     b.Property<string>("Name");
 
+                    b.Property<string>("PostalCode");
+
+                    b.Property<string>("Provice");
+
+                    b.Property<string>("ShopNumber");
+
+                    b.Property<string>("ShoppingCentre");
+
+                    b.Property<string>("StreetName");
+
+                    b.Property<string>("StreetNumber");
+
+                    b.Property<string>("Suburb");
+
                     b.HasKey("Id");
 
                     b.ToTable("Restaurants");
                 });
 
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("Image");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RestaurantCategories");
+                });
+
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
+
+                    b.Property<DateTime>("Created");
+
+                    b.Property<bool>("IsDeleted");
+
+                    b.Property<DateTime>("Modified");
+
+                    b.Property<string>("ModifiedBy");
+
+                    b.Property<int>("RestaurantId");
+
+                    b.Property<int>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RestaurantId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RestaurantUsers");
+                });
+
             modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
                 {
                     b.Property<int>("Id")
                         .ValueGeneratedOnAdd()
                         .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
+                    b.Property<bool>("Closed");
+
                     b.Property<DateTime>("ClosingTime");
 
                     b.Property<DateTime>("Created");
 
                     b.Property<string>("ModifiedBy");
 
+                    b.Property<bool>("Opened24H");
+
                     b.Property<DateTime>("OpeningTime");
 
                     b.Property<int>("RestaurantId");
             modelBuilder.Entity("ProRestaurant.Models.Accounts.UserAddress", b =>
                 {
                     b.HasOne("ProRestaurant.Models.Accounts.User", "User")
-                        .WithMany()
+                        .WithMany("Addresses")
                         .HasForeignKey("UserId")
                         .OnDelete(DeleteBehavior.Cascade);
                 });
                         .OnDelete(DeleteBehavior.Cascade);
                 });
 
+            modelBuilder.Entity("ProRestaurant.Models.Restaurants.RestaurantUser", b =>
+                {
+                    b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")
+                        .WithMany("Users")
+                        .HasForeignKey("RestaurantId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ProRestaurant.Models.Accounts.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
             modelBuilder.Entity("ProRestaurant.Models.Restaurants.TradingHours", b =>
                 {
                     b.HasOne("ProRestaurant.Models.Restaurants.Restaurant", "Restaurant")

ProRestaurant/Models/Accounts/User.cs

-using System;
+using ProRestaurant.Classes;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
         public string FirstName { get; set; }
         public string Surname { get; set; }
         public string Cellphone { get; set; }
+        public SystemRole SystemRole { get; set; }
 
         public virtual DriverDetail DriverDetails { get; set; }
-    }
+
+        public ICollection<UserAddress> Addresses { get; set; }
+    }    
 }

ProRestaurant/Models/Accounts/UserAddress.cs

     public class UserAddress : BaseObject
     {
         public int UserId { get; set; }
+        public bool IsDefault { get; set; }
+        public string GoogleMapUrl { get; set; }
         public decimal Latitude { get; set; }
         public decimal Longitude { get; set; } 
 

ProRestaurant/Models/Misc/Locations.cs

+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ProRestaurant.Models.Misc
+{
+    public class Locations
+    {
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        [Key]
+        public int Id { get; set; }
+        public string ImageStore { get; set; }
+        public string CategoryStore { get; set; }        
+    }
+}

ProRestaurant/Models/Restaurants/Restaurant.cs

-using Microsoft.AspNetCore.SignalR;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
+using System.Collections.Generic;
 
 namespace ProRestaurant.Models.Restaurants
 {
     public class Restaurant : BaseObject
     {
-        public string Name { get; set; }
-        public string Location { get; set; } //Set with google's autocomplete(suburb)
-        public string Logo { get; set; }
-        public bool Chain { get; set; } //if no, do not display the location on card
+        public string Name { get; set; }        
+        public string Logo { get; set; }        
         public decimal DeliveryFee { get; set; }
         public decimal DeliveryRadius { get; set; }
         public string MethodsOfPayment { get; set; } //Comma separated list - can be displayed as a drop down. 
-        public ICollection<TradingHours> TradingHours { get; set; }
+        public string ShoppingCentre { get; set; }
+        public string ShopNumber { get; set; }
+        public string GoogleMapUrl { get; set; }
+        public decimal Latitude { get; set; }
+        public decimal Longitude { get; set; }
+        public string StreetNumber { get; set; }
+        public string StreetName { get; set; }
+        public string Suburb { get; set; }
+        public string City { get; set; }
+        public string Provice { get; set; }
+        public string Country { get; set; }
+        public string PostalCode { get; set; }
+        public string DeliveryTime { get; set; }
+        public string Categories { get; set; }
+
+        public ICollection<TradingHours> TradingHours { get; set; }   
+        public ICollection<RestaurantUser> Users { get; set; }
     }
 }

ProRestaurant/Models/Restaurants/RestaurantCategory.cs

+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ProRestaurant.Models.Restaurants
+{
+    public class RestaurantCategory
+    {
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        [Key]
+        public int Id { get; set; }
+        public string Description { get; set; }
+        public string Image { get; set; }
+    }
+}

ProRestaurant/Models/Restaurants/RestaurantUser.cs

+using ProRestaurant.Models.Accounts;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ProRestaurant.Models.Restaurants
+{
+    public class RestaurantUser : BaseObject
+    {
+        [ForeignKey("User")]
+        public int UserId { get; set; }
+        [ForeignKey("Restaurant")]
+        public int RestaurantId { get; set; }
+
+        public virtual User User { get; set; }
+        public virtual Restaurant Restaurant { get; set; }
+    }
+}

ProRestaurant/Models/Restaurants/TradingHours.cs

         public string Description { get; set;  }
         public DateTime OpeningTime { get; set; }
         public DateTime ClosingTime { get; set; }
+        public bool Closed { get; set; }
+        public bool Opened24H { get; set; }
 
         public virtual Restaurant Restaurant { get; set; }
     }

ProRestaurant/ProRestaurant.csproj

-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp2.2</TargetFramework>
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.2.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="2.2.0" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="2.2.0" />
+    <PackageReference Include="System.Data.SQLite" Version="1.0.113.1" />
+    <PackageReference Include="System.Drawing.Common" Version="4.7.0" />
   </ItemGroup>
 
 </Project>

ProRestaurant/ProRestaurant.csproj.user

   <PropertyGroup>
     <Controller_SelectedScaffolderID>ApiControllerWithActionsScaffolder</Controller_SelectedScaffolderID>
     <Controller_SelectedScaffolderCategoryPath>root/Controller</Controller_SelectedScaffolderCategoryPath>
+    <ShowAllFiles>false</ShowAllFiles>
   </PropertyGroup>
 </Project>

ProRestaurant/Program.cs

-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.AspNetCore;
+using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.Logging;
 
 namespace ProRestaurant
 {
         public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
             WebHost.CreateDefaultBuilder(args)
                 .UseStartup<Startup>();
+
+        public static IWebHost BuildWebHost(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseStartup<Startup>()
+                .UseUrls("http://localhost:58847")
+                .Build();
     }
 }

ProRestaurant/Repository/Accounts/AuthenticateRepository.cs

+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using ProRestaurant.Classes;
+using ProRestaurant.Containers;
+using ProRestaurant.DBContexts;
+using ProRestaurant.Models.Accounts;
+using System;
+using System.Collections.Generic;
+using System.IdentityModel.Tokens.Jwt;
+using System.Linq;
+using System.Security.Claims;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ProRestaurant.Repository.Accounts
+{
+    public interface IAuthenticateRepository
+    {
+        AuthenticationContiner Login(AuthenticationContiner user);
+        AuthenticationContiner GetAuthenticationContiner();
+    }
+
+    public class AuthenticateRepository : IAuthenticateRepository
+    {
+        private readonly DBContext dBContext;
+        private readonly AppSettings appSettings;
+
+        public AuthenticateRepository(DBContext _DB, IOptions<AppSettings> _AppSettings)
+        {
+            dBContext = _DB;
+            appSettings = _AppSettings.Value;
+        }
+
+        public AuthenticationContiner GetAuthenticationContiner()
+        {
+            return new AuthenticationContiner();
+        }
+
+        public AuthenticationContiner Login(AuthenticationContiner user)
+        {
+            var getUser = dBContext.Users.Where(u => u.EmailAddress == user.EmailAddress).FirstOrDefault();
+
+            if (getUser != null)
+            {
+                if (getUser.Password == user.Password)
+                {
+                    var tokenHandler = new JwtSecurityTokenHandler();
+                    var key = Encoding.ASCII.GetBytes(appSettings.Secret);
+                    var tokenDescription = new SecurityTokenDescriptor
+                    {
+                        Subject = new ClaimsIdentity(new Claim[]
+                        {
+                            new Claim(ClaimTypes.Name, getUser.Id.ToString())
+                        }),
+                        Expires = DateTime.UtcNow.AddHours(1),
+                        SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
+                    };
+                    var token = tokenHandler.CreateToken(tokenDescription);
+                    user.Token = tokenHandler.WriteToken(token);
+                    user.Result = "Access Granted";
+                    user.Name = getUser.FirstName;
+                    user.Surname = getUser.Surname;
+                    user.EmailAddress = getUser.EmailAddress;
+                    user.Password = "";
+                    user.Role = getUser.SystemRole.ToString();
+                }
+                else
+                {
+                    user.Result = "Incorrect Password";
+                }
+            }
+            else
+            {
+                user.Result = "User Not Found.";
+            }
+            return user;
+        }
+    }
+}

ProRestaurant/Repository/Accounts/IRegistrationRepository.cs

+using ProRestaurant.Containers;
+using ProRestaurant.Models.Accounts;
+using ProRestaurant.Models.Restaurants;
+using System;
+
+namespace ProRestaurant.Repository.Accounts
+{
+    public interface IRegistrationRepository
+    {        
+        UserContainer GetUserContainer();        
+        RestaurantContainer GetRestaurantContainer();
+        UserContainer RegisterUser(UserContainer UserContainer);
+        RestaurantContainer RegisterRestaurant(RestaurantContainer RestaurantContainer);
+        void Save();                
+    }
+}

ProRestaurant/Repository/Accounts/IUserRepository.cs

-using ProRestaurant.Containers;
-using ProRestaurant.Models.Accounts;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace ProRestaurant.Repository.Accounts
-{
-    public interface IUserRepository
-    {
-        IEnumerable<User> GetUsers();
-        User GetUser(Func<User, bool> where);
-        void Insert(User user);
-        void Remove(User user);
-        void Update(User user);
-        void Save();
-        UserContainer Login(string UserName, string Password);
-    }
-}

ProRestaurant/Repository/Accounts/RegistrationRepository.cs

+using ProRestaurant.Classes;
+using ProRestaurant.Containers;
+using ProRestaurant.DBContexts;
+using ProRestaurant.Models.Accounts;
+using ProRestaurant.Models.Restaurants;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace ProRestaurant.Repository.Accounts
+{
+    public class RegistrationRepository : IRegistrationRepository
+    {
+        private readonly DBContext dBContext;
+
+        public RegistrationRepository(DBContext _DB)
+        {
+            dBContext = _DB;
+        }
+
+        public RestaurantContainer GetRestaurantContainer()
+        {
+            var restaurantContainer = new RestaurantContainer
+            {
+                Name = "",
+                Logo = "",
+                MethodsOfPayment = "",
+                ShopNumber = "",
+                ShoppingCentre = "",
+                GoogleMapUrl = "",
+                StreetNumber = "",
+                StreetName = "",
+                Suburb = "",
+                City = "",
+                Provice = "",
+                Country = "",
+
+            };
+
+            return restaurantContainer;
+        }
+
+        public UserContainer GetUserContainer()
+        {
+            var userContainer = new UserContainer()
+            {
+                FirstName = "",
+                Surname = "",
+                Cellphone = "",
+                EmailAddress = "",
+                Password = ""
+            };
+
+            return userContainer;
+        }
+
+        //public UserContainer Login(string UserName, string Password)
+        //{
+        //    UserContainer returnObject = new UserContainer();
+        //    User user = dBContext.Users.Where(u => u.EmailAddress == UserName).FirstOrDefault();
+
+        //    if (user != null)
+        //    {
+        //        if (user.Password == Password)
+        //        {
+        //            returnObject.User = user;
+        //            returnObject.ResultString = "Access Granted";
+        //        }
+        //        else
+        //            returnObject.ResultString = "Password incorrect";
+        //    }
+        //    else
+        //    {
+        //        returnObject.ResultString = "User not found";
+        //    }
+        //    return returnObject;
+        //}
+
+        public RestaurantContainer RegisterRestaurant(RestaurantContainer RestaurantContainer)
+        {            
+            var restaurantCheck = dBContext.Restaurants.Where(r => r.Name == RestaurantContainer.Name && r.Suburb == RestaurantContainer.Suburb && r.City == RestaurantContainer.City && r.Provice == RestaurantContainer.Provice && r.Country == RestaurantContainer.Country).FirstOrDefault();
+            if (restaurantCheck != null)
+            {
+                RestaurantContainer.Result = "A Restaurant with the same name has already been registered in this location. ";
+                return RestaurantContainer;
+            }
+
+            var checkUser = dBContext.Users.Where(u => u.EmailAddress == RestaurantContainer.UserEmailAddress).FirstOrDefault();
+            if (checkUser != null)
+            {
+                RestaurantContainer.Result = "A User with this email address already exists. Please use an different Email Address if this Email Address was used for an individule user.";
+                return RestaurantContainer;
+            }
+
+            var user = new User
+            {
+                FirstName = RestaurantContainer.UserFirstName,
+                Surname = RestaurantContainer.UserSurname,
+                EmailAddress = RestaurantContainer.UserEmailAddress,
+                Password = RestaurantContainer.UserPassword,
+                SystemRole = Classes.SystemRole.RestaurantAdmin
+            };
+
+            var restaurant = new Restaurant
+            {                
+                Name = RestaurantContainer.Name,
+                DeliveryTime = RestaurantContainer.DeliveryTime,
+                DeliveryFee = RestaurantContainer.DeliveryFee,
+                DeliveryRadius = RestaurantContainer.DeliveryRadius,
+                MethodsOfPayment = RestaurantContainer.MethodsOfPayment,
+                ShoppingCentre = RestaurantContainer.ShoppingCentre,
+                ShopNumber = RestaurantContainer.ShopNumber,
+                GoogleMapUrl = RestaurantContainer.GoogleMapUrl,
+                Latitude = RestaurantContainer.Latitude,
+                Longitude = RestaurantContainer.Longitude,
+                StreetNumber = RestaurantContainer.StreetNumber,
+                StreetName = RestaurantContainer.StreetName,
+                Suburb = RestaurantContainer.Suburb,
+                City = RestaurantContainer.City,
+                Provice = RestaurantContainer.Provice,
+                Country = RestaurantContainer.Country,
+                PostalCode = RestaurantContainer.PostalCode,
+                Categories = RestaurantContainer.Categories
+            };
+
+            if (!string.IsNullOrEmpty(restaurant.MethodsOfPayment))
+            {
+                restaurant.MethodsOfPayment = restaurant.MethodsOfPayment.Substring(0, restaurant.MethodsOfPayment.Length - 1);
+            }
+            
+            if (!string.IsNullOrEmpty(restaurant.Categories))
+            {
+                restaurant.Categories = restaurant.Categories.Substring(0, restaurant.Categories.Length - 1);
+                restaurant.Categories = restaurant.Categories.Replace("|", " - ");
+            }
+
+            if (!string.IsNullOrEmpty(RestaurantContainer.Logo))
+            {
+                bool saveFile = false;
+                var loc = dBContext.Locations.FirstOrDefault()?.ImageStore;
+                if (!string.IsNullOrEmpty(loc))
+                {
+                    var folderName = restaurant.Name + string.Format("{0:yyyy_MM_dd_hh_mm_ss}", DateTime.Now);
+                    saveFile = true;
+                    loc += string.Format("{0}", folderName);
+                    if (!Directory.Exists(loc))
+                    {
+                        Directory.CreateDirectory(loc);
+                    }
+
+                    if (saveFile)
+                    {
+                        string path = ImageFormatter.Base64ToImage(RestaurantContainer.Logo, loc, restaurant.Name.Trim());
+                        restaurant.Logo = path;
+                    }
+                }
+
+                if (!saveFile)
+                    restaurant.Logo = RestaurantContainer.Logo;
+            }
+
+            var rUser = new RestaurantUser
+            {
+                Restaurant = restaurant,
+                User = user
+            };
+
+            restaurant.Users = new List<RestaurantUser>() { rUser };
+
+            if (RestaurantContainer.THours != null && RestaurantContainer.THours.Count > 0)
+            {
+                restaurant.TradingHours = new List<TradingHours>();
+                foreach (var t in RestaurantContainer.THours)
+                {
+                    restaurant.TradingHours.Add(new TradingHours()
+                    {
+                        Description = t.Description,
+                        OpeningTime = DateTime.Parse(string.Format("{0} {1}", string.Format("{0:yyyy/MM/dd}", DateTime.Now), t.From)),
+                        ClosingTime = DateTime.Parse(string.Format("{0} {1}", string.Format("{0:yyyy/MM/dd}", DateTime.Now), t.To)),
+                        Closed = t.Closed,
+                        Opened24H = t.Open24
+                    });
+                }
+            }           
+
+            dBContext.Add(restaurant);
+            Save();
+
+            return RestaurantContainer;
+        }
+
+        public UserContainer RegisterUser(UserContainer UserContainer)
+        {
+            var checkUser = dBContext.Users.Where(u => u.EmailAddress == UserContainer.EmailAddress).FirstOrDefault();
+            if (checkUser != null)
+            {
+                UserContainer.ResultString = "A User with this email address already exists.";
+                UserContainer.Password = "";
+                return UserContainer;
+            }
+
+            var user = new User
+            {
+                FirstName = UserContainer.FirstName,
+                Surname = UserContainer.Surname,
+                Cellphone = UserContainer.Cellphone,
+                EmailAddress = UserContainer.EmailAddress,
+                Password = UserContainer.Password,
+                SystemRole = Classes.SystemRole.Customer
+            };
+
+            dBContext.Add(user);
+            Save();
+
+            UserContainer.Id = user.Id;
+            UserContainer.ResultString = "User Created";
+
+            return UserContainer;
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+    }
+}

ProRestaurant/Repository/Accounts/UserRepository.cs

-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Internal;
-using ProRestaurant.Classes;
-using ProRestaurant.Containers;
-using ProRestaurant.DBContexts;
-using ProRestaurant.Models.Accounts;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Text.RegularExpressions;
-
-namespace ProRestaurant.Repository.Accounts
-{
-    public class UserRepository : IUserRepository
-    {
-        private readonly DBContext dBContext;
-
-        public UserRepository(DBContext _DB)
-        {
-            dBContext = _DB;
-        }
-
-        public User GetUser(Func<User, bool> where)
-        {
-            var user = dBContext.Users.Where(where).FirstOrDefault();
-            if (user == null)
-            {
-                user = new User
-                {
-                    EmailAddress = "",
-                    Password = "",
-                    FirstName = "",
-                    Surname = "",
-                    Cellphone = ""
-                };
-            }
-            return user;
-        }
-
-        public IEnumerable<User> GetUsers()
-        {
-            return dBContext.Users.ToList();
-        }
-
-        public void Insert(User user)
-        {            
-            dBContext.Add(user);
-            Save();
-        }
-
-        public UserContainer Login(string UserName, string Password)
-        {
-            UserContainer returnObject = new UserContainer();
-            User user;
-
-            string pattern = @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z";
-            if (Regex.IsMatch(UserName, pattern))
-                user = dBContext.Users.Where(u => u.EmailAddress == UserName).FirstOrDefault();
-            else
-                user = dBContext.Users.Where(u => u.Cellphone == UserName).FirstOrDefault();
-
-            if (user != null)
-            {
-                if (user.Password == Password)
-                {
-                    returnObject.user = user;
-                    returnObject.ResultString = "Access Granted";
-                }
-                else
-                    returnObject.ResultString = "Password incorrect";
-            }
-            else
-            {
-                returnObject.ResultString = "User not found";
-            }
-
-
-            return returnObject;
-        }
-
-        public void Remove(User user)
-        {
-            dBContext.Users.Remove(user);
-            Save();
-        }
-
-        public void Save()
-        {
-            dBContext.SaveChanges();
-        }
-
-        public void Update(User user)
-        {
-            dBContext.Entry(user).State = EntityState.Modified;
-            Save();
-        }
-    }
-}

ProRestaurant/Repository/Restaurants/IMenuCategoryRepository.cs

+using ProRestaurant.Models.Restaurants;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace ProRestaurant.Repository.Restaurants
+{
+    public interface IMenuCategoryRepository
+    {
+        IEnumerable<MenuCategory> GetMenuCategory();
+        IEnumerable<MenuCategory> GetMenuCategories(Func<MenuCategory, bool> where);
+        MenuCategory GetMenuCategory(Func<MenuCategory, bool> where);
+        void Insert(MenuCategory MenuCategory);
+        void Remove(MenuCategory MenuCategory);
+        void Update(MenuCategory MenuCategory);
+        void Save();
+    }
+}

ProRestaurant/Repository/Restaurants/IRestaurantCategoryRepository.cs

+using ProRestaurant.Models.Restaurants;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace ProRestaurant.Repository.Restaurants
+{
+    public interface IRestaurantCategoryRepository
+    {
+        ICollection<RestaurantCategory> Get();
+        void Insert(RestaurantCategory RestaurantCategory);
+        void Update(RestaurantCategory RestaurantCategory);
+        void Remove(int id);
+        void Save();
+    }
+}

ProRestaurant/Repository/Restaurants/IRestaurantRepository.cs

-using ProRestaurant.Models.Restaurants;
+using ProRestaurant.Containers;
+using ProRestaurant.Models.Restaurants;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 namespace ProRestaurant.Repository.Restaurants
 {
     public interface IRestaurantRepository
-    {
-        IEnumerable<Restaurant> GetUsers();
+    {        
+        List<RestaurantCard> GetSearch();
         Restaurant GetRestaurant(Func<Restaurant, bool> where);
         void Insert(Restaurant restaurant);
         void Remove(Restaurant restaurant);

ProRestaurant/Repository/Restaurants/MenuCategoryRepository.cs

+using Microsoft.EntityFrameworkCore;
+using ProRestaurant.DBContexts;
+using ProRestaurant.Models.Restaurants;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace ProRestaurant.Repository.Restaurants
+{
+    public class MenuCategoryRepository : IMenuCategoryRepository
+    {
+        private readonly DBContext dBContext;
+
+        public MenuCategoryRepository(DBContext db)
+        {
+            dBContext = db;
+        }
+
+        public IEnumerable<MenuCategory> GetMenuCategory()
+        {
+            return dBContext.MenuCategories.ToList();
+        }
+
+        public IEnumerable<MenuCategory> GetMenuCategories(Func<MenuCategory, bool> where)
+        {
+            return dBContext.MenuCategories.Where(where).ToList();
+        }
+
+        public MenuCategory GetMenuCategory(Func<MenuCategory, bool> where)
+        {
+            return dBContext.MenuCategories.Where(where).FirstOrDefault();
+        }
+
+        public void Insert(MenuCategory MenuCategory)
+        {
+            dBContext.Add(MenuCategory);
+            Save();
+        }
+
+        public void Remove(MenuCategory MenuCategory)
+        {
+            dBContext.Remove(MenuCategory);
+            Save();
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(MenuCategory MenuCategory)
+        {
+            dBContext.Entry(MenuCategory).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

ProRestaurant/Repository/Restaurants/RestaurantCategoryRepository.cs

+using Microsoft.EntityFrameworkCore;
+using ProRestaurant.Classes;
+using ProRestaurant.DBContexts;
+using ProRestaurant.Models.Restaurants;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ProRestaurant.Repository.Restaurants
+{
+    public class RestaurantCategoryRepository : IRestaurantCategoryRepository
+    {
+        private readonly DBContext dBContext;
+
+        public RestaurantCategoryRepository(DBContext _DB)
+        {
+            dBContext = _DB;
+        }
+
+        public ICollection<RestaurantCategory> Get()
+        {
+            var cats = dBContext.RestaurantCategories.OrderBy(c => c.Description).ToList();
+
+            foreach (var cat in cats)
+            {
+                if (!string.IsNullOrEmpty(cat.Image) && !cat.Image.Contains("data:image"))
+                    cat.Image = ImageFormatter.ImageToBase64(cat.Image);
+            }
+
+            return cats;
+        }
+
+        public void Insert(RestaurantCategory RestaurantCategory)
+        {
+            dBContext.Add(RestaurantCategory);
+            Save();
+        }
+
+        public void Remove(int id)
+        {
+            var category = dBContext.RestaurantCategories.Where(r => r.Id == id).FirstOrDefault();
+            dBContext.Remove(category);
+            Save();
+        }
+
+        public void Save()
+        {
+            dBContext.SaveChanges();
+        }
+
+        public void Update(RestaurantCategory RestaurantCategory)
+        {
+            dBContext.Entry(RestaurantCategory).State = EntityState.Modified;
+            Save();
+        }
+    }
+}

ProRestaurant/Repository/Restaurants/RestaurantRepository.cs

 using Microsoft.EntityFrameworkCore;
+using ProRestaurant.Classes;
+using ProRestaurant.Containers;
 using ProRestaurant.DBContexts;
 using ProRestaurant.Models.Restaurants;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace ProRestaurant.Repository.Restaurants
 {
             return dBContext.Restaurants.Where(where).FirstOrDefault();
         }
 
-        public IEnumerable<Restaurant> GetUsers()
+        public IEnumerable<Restaurant> GetRestaurants()
         {
             return dBContext.Restaurants.ToList();
         }
 
+        public List<RestaurantCard> GetSearch()
+        {
+            var restaurants = dBContext.Restaurants.ToList();
+
+            List<RestaurantCard> cards = new List<RestaurantCard>();
+
+            foreach (var rest in restaurants)
+            {
+                var card = new RestaurantCard
+                {
+                    Id = rest.Id,
+                    Name = rest.Name,
+                    Suburb = rest.Suburb,
+                    SubText = rest.Categories,
+                    DeliveryFee = string.Format("{0:C}", rest.DeliveryFee),
+                    DeliveryTime = rest.DeliveryTime
+                };
+                if (!rest.Logo.Contains("data:image"))
+                    card.Logo = ImageFormatter.ImageToBase64(rest.Logo);
+                else
+                    card.Logo = rest.Logo;
+
+                cards.Add(card);
+            }
+
+            return cards;
+        }
+
         public void Insert(Restaurant restaurant)
         {
             dBContext.Add(restaurant);
         {
             dBContext.Entry(restaurant).State = EntityState.Modified;
             Save();
-        }
+        }        
     }
 }

ProRestaurant/Startup.cs

 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.HttpsPolicy;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using ProRestaurant.Classes;
 using ProRestaurant.DBContexts;
 using ProRestaurant.Repository.Accounts;
+using ProRestaurant.Repository.Restaurants;
 
 namespace ProRestaurant
 {
                        .AllowAnyHeader();
             }));
             services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
-            services.AddDbContext<DBContext>(o => o.UseSqlServer(Configuration.GetConnectionString("DefaultDatabase")));
 
-            services.AddTransient<IUserRepository, UserRepository>();
+            #region Authentication Setup
+            // configure strongly typed settings objects
+            var appSettingsSection = Configuration.GetSection("AppSettings");
+            services.Configure<AppSettings>(appSettingsSection);
 
+            // configure jwt authentication
+            var appSettings = appSettingsSection.Get<AppSettings>();
+            var key = Encoding.ASCII.GetBytes(appSettings.Secret);
+            services.AddAuthentication(x =>
+            {
+                x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+                x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+            })
+            .AddJwtBearer(x =>
+            {
+                x.RequireHttpsMetadata = false;
+                x.SaveToken = true;
+                x.TokenValidationParameters = new TokenValidationParameters
+                {
+                    ValidateIssuerSigningKey = true,
+                    IssuerSigningKey = new SymmetricSecurityKey(key),
+                    ValidateIssuer = false,
+                    ValidateAudience = false
+                };
+            });
+
+            // configure DI for application services
+            services.AddScoped<IAuthenticateRepository, AuthenticateRepository>();
+            #endregion
+
+
+            services.AddDbContext<DBContext>(o => o.UseSqlServer(Configuration.GetConnectionString("DefaultDatabase")));           
+
+            services.AddTransient<IRegistrationRepository, RegistrationRepository>();
+            services.AddTransient<IRestaurantCategoryRepository, RestaurantCategoryRepository>();
+            services.AddTransient<IRestaurantRepository, RestaurantRepository>();
 
             services.Configure<MvcOptions>(options =>
             {

ProRestaurant/appsettings.json

-{
+{
+  "AppSettings": {
+    "Secret": "≡∆≤≥√∞ProVision!"
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Warning"

ProRestaurant/bin/Debug/netcoreapp2.2/ProRestaurant.deps.json

           "Microsoft.EntityFrameworkCore": "2.2.0",
           "Microsoft.EntityFrameworkCore.SqlServer": "2.2.0",
           "Microsoft.NETCore.App": "2.2.0",
-          "Npgsql.EntityFrameworkCore.PostgreSQL": "2.2.0"
+          "Npgsql.EntityFrameworkCore.PostgreSQL": "2.2.0",
+          "System.Data.SQLite": "1.0.113.1",
+          "System.Drawing.Common": "4.7.0"
         },
         "runtime": {
           "ProRestaurant.dll": {}
           "ProRestaurant.dll": {}
         }
       },
+      "Microsoft.NETCore.Platforms/3.1.0": {},
+      "Microsoft.Win32.SystemEvents/4.7.0": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "3.1.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Win32.SystemEvents.dll": {
+            "assemblyVersion": "4.0.2.0",
+            "fileVersion": "4.700.19.56404"
+          }
+        },
+        "runtimeTargets": {
+          "runtimes/win/lib/netcoreapp2.0/Microsoft.Win32.SystemEvents.dll": {
+            "rid": "win",
+            "assetType": "runtime",
+            "assemblyVersion": "4.0.2.0",
+            "fileVersion": "4.700.19.56404"
+          }
+        }
+      },
       "Npgsql/4.0.4": {
         "dependencies": {
           "System.Runtime.CompilerServices.Unsafe": "4.5.1",
           "lib/netstandard2.0/Npgsql.EntityFrameworkCore.PostgreSQL.dll": {}
         }
       },
+      "System.Data.SQLite/1.0.113.1": {
+        "dependencies": {
+          "System.Data.SQLite.Core": "1.0.113.1"
+        }
+      },
+      "System.Data.SQLite.Core/1.0.113.1": {
+        "runtime": {
+          "lib/netstandard2.0/System.Data.SQLite.dll": {
+            "assemblyVersion": "1.0.113.0",
+            "fileVersion": "1.0.113.0"
+          }
+        },
+        "runtimeTargets": {
+          "runtimes/linux-x64/native/netstandard2.0/SQLite.Interop.dll": {
+            "rid": "linux-x64",
+            "assetType": "native",
+            "fileVersion": "0.0.0.0"
+          },
+          "runtimes/linux-x64/native/netstandard2.1/SQLite.Interop.dll": {
+            "rid": "linux-x64",
+            "assetType": "native",
+            "fileVersion": "0.0.0.0"
+          },
+          "runtimes/osx-x64/native/netstandard2.0/SQLite.Interop.dll": {
+            "rid": "osx-x64",
+            "assetType": "native",
+            "fileVersion": "0.0.0.0"
+          },
+          "runtimes/osx-x64/native/netstandard2.1/SQLite.Interop.dll": {
+            "rid": "osx-x64",
+            "assetType": "native",
+            "fileVersion": "0.0.0.0"
+          },
+          "runtimes/win-x64/native/netstandard2.0/SQLite.Interop.dll": {
+            "rid": "win-x64",
+            "assetType": "native",
+            "fileVersion": "1.0.113.0"
+          },
+          "runtimes/win-x64/native/netstandard2.1/SQLite.Interop.dll": {
+            "rid": "win-x64",
+            "assetType": "native",
+            "fileVersion": "1.0.113.0"
+          },
+          "runtimes/win-x86/native/netstandard2.0/SQLite.Interop.dll": {
+            "rid": "win-x86",
+            "assetType": "native",
+            "fileVersion": "1.0.113.0"
+          },
+          "runtimes/win-x86/native/netstandard2.1/SQLite.Interop.dll": {
+            "rid": "win-x86",
+            "assetType": "native",
+            "fileVersion": "1.0.113.0"
+          }
+        },
+        "compile": {
+          "lib/netstandard2.0/System.Data.SQLite.dll": {}
+        }
+      },
+      "System.Drawing.Common/4.7.0": {
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "3.1.0",
+          "Microsoft.Win32.SystemEvents": "4.7.0"
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Drawing.Common.dll": {
+            "assemblyVersion": "4.0.0.1",
+            "fileVersion": "4.6.26919.2"
+          }
+        },
+        "runtimeTargets": {
+          "runtimes/unix/lib/netcoreapp2.0/System.Drawing.Common.dll": {
+            "rid": "unix",
+            "assetType": "runtime",
+            "assemblyVersion": "4.0.0.1",
+            "fileVersion": "4.6.26919.2"
+          },
+          "runtimes/win/lib/netcoreapp2.0/System.Drawing.Common.dll": {
+            "rid": "win",
+            "assetType": "runtime",
+            "assemblyVersion": "4.0.0.1",
+            "fileVersion": "4.6.26919.2"
+          }
+        },
+        "compile": {
+          "ref/netstandard2.0/System.Drawing.Common.dll": {}
+        }
+      },
       "System.ValueTuple/4.5.0": {},
       "Microsoft.AspNet.WebApi.Client/5.2.6": {
         "dependencies": {
       "Microsoft.NETCore.App/2.2.0": {
         "dependencies": {
           "Microsoft.NETCore.DotNetHostPolicy": "2.2.0",
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "NETStandard.Library": "2.0.3"
         },
         },
         "compileOnly": true
       },
-      "Microsoft.NETCore.Platforms/2.2.0": {
-        "compileOnly": true
-      },
       "Microsoft.NETCore.Targets/2.0.0": {
         "compileOnly": true
       },
       },
       "NETStandard.Library/2.0.3": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0"
+          "Microsoft.NETCore.Platforms": "3.1.0"
         },
         "compileOnly": true
       },
       },
       "runtime.native.System/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0"
         },
         "compileOnly": true
       },
       "runtime.native.System.IO.Compression/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0"
         },
         "compileOnly": true
       },
       "runtime.native.System.Net.Http/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0"
         },
         "compileOnly": true
       },
       "System.Collections/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Console/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.IO": "4.3.0",
           "System.Runtime": "4.3.0",
       },
       "System.Diagnostics.Debug/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Diagnostics.FileVersionInfo/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Globalization": "4.3.0",
           "System.IO": "4.3.0",
           "System.IO.FileSystem": "4.3.0",
       },
       "System.Diagnostics.Tools/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Diagnostics.Tracing/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Globalization/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Globalization.Calendars/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Globalization": "4.3.0",
           "System.Runtime": "4.3.0"
       },
       "System.Globalization.Extensions/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Globalization": "4.3.0",
           "System.Resources.ResourceManager": "4.3.0",
           "System.Runtime": "4.3.0",
       },
       "System.IO/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0",
           "System.Text.Encoding": "4.3.0",
       },
       "System.IO.Compression/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Buffers": "4.5.0",
           "System.Collections": "4.3.0",
           "System.Diagnostics.Debug": "4.3.0",
       },
       "System.IO.FileSystem/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.IO": "4.3.0",
           "System.IO.FileSystem.Primitives": "4.3.0",
       },
       "System.Net.Http/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Collections": "4.3.0",
           "System.Diagnostics.Debug": "4.3.0",
           "System.Diagnostics.DiagnosticSource": "4.5.0",
       },
       "System.Net.Primitives/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0",
           "System.Runtime.Handles": "4.3.0"
       },
       "System.Reflection/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.IO": "4.3.0",
           "System.Reflection.Primitives": "4.3.0",
       },
       "System.Reflection.Extensions/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Reflection": "4.3.0",
           "System.Runtime": "4.3.0"
       },
       "System.Reflection.Primitives/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Resources.ResourceManager/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Globalization": "4.3.0",
           "System.Reflection": "4.3.0",
       },
       "System.Runtime/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0"
         },
         "compileOnly": true
       },
       "System.Runtime.Extensions/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Runtime.Handles/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Runtime.InteropServices/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Reflection": "4.3.0",
           "System.Reflection.Primitives": "4.3.0",
       },
       "System.Security.AccessControl/4.5.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Security.Principal.Windows": "4.5.0"
         },
         "compile": {
       },
       "System.Security.Cryptography.Algorithms/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Collections": "4.3.0",
           "System.IO": "4.3.0",
           "System.Resources.ResourceManager": "4.3.0",
       },
       "System.Security.Cryptography.Csp/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.IO": "4.3.0",
           "System.Reflection": "4.3.0",
           "System.Resources.ResourceManager": "4.3.0",
       },
       "System.Security.Cryptography.Encoding/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Collections": "4.3.0",
           "System.Collections.Concurrent": "4.3.0",
           "System.Linq": "4.3.0",
       },
       "System.Security.Cryptography.X509Certificates/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Collections": "4.3.0",
           "System.Diagnostics.Debug": "4.3.0",
           "System.Globalization": "4.3.0",
       },
       "System.Security.Principal.Windows/4.5.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0"
+          "Microsoft.NETCore.Platforms": "3.1.0"
         },
         "compile": {
           "ref/netstandard2.0/System.Security.Principal.Windows.dll": {}
       },
       "System.Text.Encoding/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       },
       "System.Text.Encoding.CodePages/4.5.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "System.Runtime.CompilerServices.Unsafe": "4.5.1"
         },
         "compileOnly": true
       },
       "System.Text.Encoding.Extensions/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0",
           "System.Text.Encoding": "4.3.0"
       },
       "System.Threading.Tasks/4.3.0": {
         "dependencies": {
-          "Microsoft.NETCore.Platforms": "2.2.0",
+          "Microsoft.NETCore.Platforms": "3.1.0",
           "Microsoft.NETCore.Targets": "2.0.0",
           "System.Runtime": "4.3.0"
         },
       "serviceable": false,
       "sha512": ""
     },
+    "Microsoft.NETCore.Platforms/3.1.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-z7aeg8oHln2CuNulfhiLYxCVMPEwBl3rzicjvIX+4sUuCwvXw5oXQEtbiU2c0z4qYL5L3Kmx0mMA/+t/SbY67w==",
+      "path": "microsoft.netcore.platforms/3.1.0",
+      "hashPath": "microsoft.netcore.platforms.3.1.0.nupkg.sha512"
+    },
+    "Microsoft.Win32.SystemEvents/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-mtVirZr++rq+XCDITMUdnETD59XoeMxSpLRIII7JRI6Yj0LEDiO1pPn0ktlnIj12Ix8bfvQqQDMMIF9wC98oCA==",
+      "path": "microsoft.win32.systemevents/4.7.0",
+      "hashPath": "microsoft.win32.systemevents.4.7.0.nupkg.sha512"
+    },
     "Npgsql/4.0.4": {
       "type": "package",
       "serviceable": true,
       "path": "npgsql.entityframeworkcore.postgresql/2.2.0",
       "hashPath": "npgsql.entityframeworkcore.postgresql.2.2.0.nupkg.sha512"
     },
+    "System.Data.SQLite/1.0.113.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-80q28QKsEebMm1PhCBEKFoxTYiE6P1YtA+5IVlBeBxgB8LwDgbaAml6RIfGu719JoRtbmNqtLdhDA8jj84s0gA==",
+      "path": "system.data.sqlite/1.0.113.1",
+      "hashPath": "system.data.sqlite.1.0.113.1.nupkg.sha512"
+    },
+    "System.Data.SQLite.Core/1.0.113.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ymvB558/Tgdxj2MzJjhDvPLJ/S2WgG1KzQ1cmqzsW3+YQ5DO+eAU04OpY5deK6fndM+DEU8+lwmmYHxxUS2Qvw==",
+      "path": "system.data.sqlite.core/1.0.113.1",
+      "hashPath": "system.data.sqlite.core.1.0.113.1.nupkg.sha512"
+    },
+    "System.Drawing.Common/4.7.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-v+XbyYHaZjDfn0ENmJEV1VYLgGgCTx1gnfOBcppowbpOAriglYgGCvFCPr2EEZyBvXlpxbEsTwkOlInl107ahA==",
+      "path": "system.drawing.common/4.7.0",
+      "hashPath": "system.drawing.common.4.7.0.nupkg.sha512"
+    },
     "System.ValueTuple/4.5.0": {
       "type": "package",
       "serviceable": true,
       "path": "microsoft.netcore.dotnethostresolver/2.2.0",
       "hashPath": "microsoft.netcore.dotnethostresolver.2.2.0.nupkg.sha512"
     },
-    "Microsoft.NETCore.Platforms/2.2.0": {
-      "type": "package",
-      "serviceable": true,
-      "sha512": "sha512-39+GVHdbm+cmoOjdvm+fhiMbddnuVyUlBdYS8Yhn5xsNaBoTXpgBsxQQlI2Sv9EjIP0F+itG6yrDaOM2OEGupQ==",
-      "path": "microsoft.netcore.platforms/2.2.0",
-      "hashPath": "microsoft.netcore.platforms.2.2.0.nupkg.sha512"
-    },
     "Microsoft.NETCore.Targets/2.0.0": {
       "type": "package",
       "serviceable": true,

ProRestaurant/bin/Debug/netcoreapp2.2/appsettings.json

-{
+{
+  "AppSettings": {
+    "Secret": "≡∆≤≥√∞ProVision!"
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Warning"

ProRestaurant/obj/Debug/netcoreapp2.2/ProRestaurant.csproj.CoreCompileInputs.cache

-77194c0e6065fe8ba524baf1a69af7e606ad6513
+d43a7af6b2b5d7d9d5ce44deb53c19ad484cc2cc

ProRestaurant/obj/Debug/netcoreapp2.2/ProRestaurant.csproj.FileListAbsolute.txt

 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.csprojAssemblyReference.cache
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.AssemblyInfoInputs.cache
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.AssemblyInfo.cs
-C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.csproj.CoreCompileInputs.cache
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.RazorAssemblyInfo.cache
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.RazorAssemblyInfo.cs
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.RazorTargetAssemblyInfo.cache
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.dll
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.pdb
 C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.genruntimeconfig.cache
+C:\Work\Development\ProRestaurant\RestaurantSite_API\ProRestaurant\obj\Debug\netcoreapp2.2\ProRestaurant.csproj.CoreCompileInputs.cache

ProRestaurant/obj/ProRestaurant.csproj.nuget.dgspec.json

             "Npgsql.EntityFrameworkCore.PostgreSQL": {
               "target": "Package",
               "version": "[2.2.0, )"
+            },
+            "System.Data.SQLite": {
+              "target": "Package",
+              "version": "[1.0.113.1, )"
+            },
+            "System.Drawing.Common": {
+              "target": "Package",
+              "version": "[4.7.0, )"
             }
           },
           "imports": [

ProRestaurant/obj/project.assets.json

           "Microsoft.NETCore.DotNetAppHost": "2.2.0"
         }
       },
-      "Microsoft.NETCore.Platforms/2.2.0": {
+      "Microsoft.NETCore.Platforms/3.1.0": {
         "type": "package",
         "compile": {
           "lib/netstandard1.0/_._": {}
           }
         }
       },
+      "Microsoft.Win32.SystemEvents/4.7.0": {
+        "type": "package",
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "3.1.0"
+        },
+        "compile": {
+          "ref/netstandard2.0/_._": {}
+        },
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Win32.SystemEvents.dll": {}
+        },
+        "runtimeTargets": {
+          "runtimes/win/lib/netcoreapp2.0/Microsoft.Win32.SystemEvents.dll": {
+            "assetType": "runtime",
+            "rid": "win"
+          }
+        }
+      },
       "NETStandard.Library/2.0.3": {
         "type": "package",
         "dependencies": {
           }
         }
       },
+      "System.Data.SQLite/1.0.113.1": {
+        "type": "package",
+        "dependencies": {
+          "System.Data.SQLite.Core": "1.0.113.1"
+        }
+      },
+      "System.Data.SQLite.Core/1.0.113.1": {
+        "type": "package",
+        "compile": {
+          "lib/netstandard2.0/System.Data.SQLite.dll": {}
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Data.SQLite.dll": {}
+        },
+        "runtimeTargets": {
+          "runtimes/linux-x64/native/netstandard2.0/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "linux-x64"
+          },
+          "runtimes/linux-x64/native/netstandard2.1/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "linux-x64"
+          },
+          "runtimes/osx-x64/native/netstandard2.0/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "osx-x64"
+          },
+          "runtimes/osx-x64/native/netstandard2.1/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "osx-x64"
+          },
+          "runtimes/win-x64/native/netstandard2.0/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "win-x64"
+          },
+          "runtimes/win-x64/native/netstandard2.1/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "win-x64"
+          },
+          "runtimes/win-x86/native/netstandard2.0/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "win-x86"
+          },
+          "runtimes/win-x86/native/netstandard2.1/SQLite.Interop.dll": {
+            "assetType": "native",
+            "rid": "win-x86"
+          }
+        }
+      },
       "System.Diagnostics.Contracts/4.3.0": {
         "type": "package",
         "dependencies": {
           "ref/netstandard1.5/System.Diagnostics.Tracing.dll": {}
         }
       },
+      "System.Drawing.Common/4.7.0": {
+        "type": "package",
+        "dependencies": {
+          "Microsoft.NETCore.Platforms": "3.1.0",
+          "Microsoft.Win32.SystemEvents": "4.7.0"
+        },
+        "compile": {
+          "ref/netstandard2.0/System.Drawing.Common.dll": {}
+        },
+        "runtime": {
+          "lib/netstandard2.0/System.Drawing.Common.dll": {}
+        },
+        "runtimeTargets": {
+          "runtimes/unix/lib/netcoreapp2.0/System.Drawing.Common.dll": {
+            "assetType": "runtime",
+            "rid": "unix"
+          },
+          "runtimes/win/lib/netcoreapp2.0/System.Drawing.Common.dll": {
+            "assetType": "runtime",
+            "rid": "win"
+          }
+        }
+      },
       "System.Dynamic.Runtime/4.3.0": {
         "type": "package",
         "dependencies": {
         "runtime.json"
       ]
     },
-    "Microsoft.NETCore.Platforms/2.2.0": {
-      "sha512": "39+GVHdbm+cmoOjdvm+fhiMbddnuVyUlBdYS8Yhn5xsNaBoTXpgBsxQQlI2Sv9EjIP0F+itG6yrDaOM2OEGupQ==",
+    "Microsoft.NETCore.Platforms/3.1.0": {
+      "sha512": "z7aeg8oHln2CuNulfhiLYxCVMPEwBl3rzicjvIX+4sUuCwvXw5oXQEtbiU2c0z4qYL5L3Kmx0mMA/+t/SbY67w==",
       "type": "package",
-      "path": "microsoft.netcore.platforms/2.2.0",
+      "path": "microsoft.netcore.platforms/3.1.0",
       "files": [
         ".nupkg.metadata",
         ".signature.p7s",
         "LICENSE.TXT",
         "THIRD-PARTY-NOTICES.TXT",
         "lib/netstandard1.0/_._",
-        "microsoft.netcore.platforms.2.2.0.nupkg.sha512",
+        "microsoft.netcore.platforms.3.1.0.nupkg.sha512",
         "microsoft.netcore.platforms.nuspec",
         "runtime.json",
         "useSharedDesignerContext.txt",
         "version.txt"
       ]
     },
+    "Microsoft.Win32.SystemEvents/4.7.0": {
+      "sha512": "mtVirZr++rq+XCDITMUdnETD59XoeMxSpLRIII7JRI6Yj0LEDiO1pPn0ktlnIj12Ix8bfvQqQDMMIF9wC98oCA==",
+      "type": "package",
+      "path": "microsoft.win32.systemevents/4.7.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE.TXT",
+        "THIRD-PARTY-NOTICES.TXT",
+        "lib/net461/Microsoft.Win32.SystemEvents.dll",
+        "lib/net461/Microsoft.Win32.SystemEvents.xml",
+        "lib/netstandard2.0/Microsoft.Win32.SystemEvents.dll",
+        "lib/netstandard2.0/Microsoft.Win32.SystemEvents.xml",
+        "microsoft.win32.systemevents.4.7.0.nupkg.sha512",
+        "microsoft.win32.systemevents.nuspec",
+        "ref/net461/Microsoft.Win32.SystemEvents.dll",
+        "ref/net461/Microsoft.Win32.SystemEvents.xml",
+        "ref/net472/Microsoft.Win32.SystemEvents.dll",
+        "ref/net472/Microsoft.Win32.SystemEvents.xml",
+        "ref/netstandard2.0/Microsoft.Win32.SystemEvents.dll",
+        "ref/netstandard2.0/Microsoft.Win32.SystemEvents.xml",
+        "runtimes/win/lib/netcoreapp2.0/Microsoft.Win32.SystemEvents.dll",
+        "runtimes/win/lib/netcoreapp2.0/Microsoft.Win32.SystemEvents.xml",
+        "runtimes/win/lib/netcoreapp3.0/Microsoft.Win32.SystemEvents.dll",
+        "runtimes/win/lib/netcoreapp3.0/Microsoft.Win32.SystemEvents.xml",
+        "useSharedDesignerContext.txt",
+        "version.txt"
+      ]
+    },
     "NETStandard.Library/2.0.3": {
       "sha512": "st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
       "type": "package",
         "version.txt"
       ]
     },
+    "System.Data.SQLite/1.0.113.1": {
+      "sha512": "80q28QKsEebMm1PhCBEKFoxTYiE6P1YtA+5IVlBeBxgB8LwDgbaAml6RIfGu719JoRtbmNqtLdhDA8jj84s0gA==",
+      "type": "package",
+      "path": "system.data.sqlite/1.0.113.1",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "system.data.sqlite.1.0.113.1.nupkg.sha512",
+        "system.data.sqlite.nuspec"
+      ]
+    },
+    "System.Data.SQLite.Core/1.0.113.1": {
+      "sha512": "ymvB558/Tgdxj2MzJjhDvPLJ/S2WgG1KzQ1cmqzsW3+YQ5DO+eAU04OpY5deK6fndM+DEU8+lwmmYHxxUS2Qvw==",
+      "type": "package",
+      "path": "system.data.sqlite.core/1.0.113.1",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "build/net20/System.Data.SQLite.Core.targets",
+        "build/net20/x64/SQLite.Interop.dll",
+        "build/net20/x86/SQLite.Interop.dll",
+        "build/net40/System.Data.SQLite.Core.targets",
+        "build/net40/x64/SQLite.Interop.dll",
+        "build/net40/x86/SQLite.Interop.dll",
+        "build/net45/System.Data.SQLite.Core.targets",
+        "build/net45/x64/SQLite.Interop.dll",
+        "build/net45/x86/SQLite.Interop.dll",
+        "build/net451/System.Data.SQLite.Core.targets",
+        "build/net451/x64/SQLite.Interop.dll",
+        "build/net451/x86/SQLite.Interop.dll",
+        "build/net46/System.Data.SQLite.Core.targets",
+        "build/net46/x64/SQLite.Interop.dll",
+        "build/net46/x86/SQLite.Interop.dll",
+        "lib/net20/System.Data.SQLite.dll",
+        "lib/net20/System.Data.SQLite.dll.config",
+        "lib/net20/System.Data.SQLite.xml",
+        "lib/net40/System.Data.SQLite.dll",
+        "lib/net40/System.Data.SQLite.dll.config",
+        "lib/net40/System.Data.SQLite.xml",
+        "lib/net45/System.Data.SQLite.dll",
+        "lib/net45/System.Data.SQLite.dll.config",
+        "lib/net45/System.Data.SQLite.xml",
+        "lib/net451/System.Data.SQLite.dll",
+        "lib/net451/System.Data.SQLite.dll.config",
+        "lib/net451/System.Data.SQLite.xml",
+        "lib/net46/System.Data.SQLite.dll",
+        "lib/net46/System.Data.SQLite.dll.config",
+        "lib/net46/System.Data.SQLite.xml",
+        "lib/netstandard2.0/System.Data.SQLite.dll",
+        "lib/netstandard2.0/System.Data.SQLite.dll.config",
+        "lib/netstandard2.0/System.Data.SQLite.xml",
+        "lib/netstandard2.1/System.Data.SQLite.dll",
+        "lib/netstandard2.1/System.Data.SQLite.dll.config",
+        "lib/netstandard2.1/System.Data.SQLite.xml",
+        "runtimes/linux-x64/native/netstandard2.0/SQLite.Interop.dll",
+        "runtimes/linux-x64/native/netstandard2.1/SQLite.Interop.dll",
+        "runtimes/osx-x64/native/netstandard2.0/SQLite.Interop.dll",
+        "runtimes/osx-x64/native/netstandard2.1/SQLite.Interop.dll",
+        "runtimes/win-x64/native/netstandard2.0/SQLite.Interop.dll",
+        "runtimes/win-x64/native/netstandard2.1/SQLite.Interop.dll",
+        "runtimes/win-x86/native/netstandard2.0/SQLite.Interop.dll",
+        "runtimes/win-x86/native/netstandard2.1/SQLite.Interop.dll",
+        "system.data.sqlite.core.1.0.113.1.nupkg.sha512",
+        "system.data.sqlite.core.nuspec"
+      ]
+    },
     "System.Diagnostics.Contracts/4.3.0": {
       "sha512": "clL6acqvIbbx3JYunlkrWV5sP9qGd0sLl612eXrBVVwakTTlMNtvZB5RiC2rU2uYxSnIt2ssUQgA2adrYSqYhA==",
       "type": "package",
         "system.diagnostics.tracing.nuspec"
       ]
     },
+    "System.Drawing.Common/4.7.0": {
+      "sha512": "v+XbyYHaZjDfn0ENmJEV1VYLgGgCTx1gnfOBcppowbpOAriglYgGCvFCPr2EEZyBvXlpxbEsTwkOlInl107ahA==",
+      "type": "package",
+      "path": "system.drawing.common/4.7.0",
+      "files": [
+        ".nupkg.metadata",
+        ".signature.p7s",
+        "LICENSE.TXT",
+        "THIRD-PARTY-NOTICES.TXT",
+        "lib/MonoAndroid10/_._",
+        "lib/MonoTouch10/_._",
+        "lib/net461/System.Drawing.Common.dll",
+        "lib/netstandard2.0/System.Drawing.Common.dll",
+        "lib/xamarinios10/_._",
+        "lib/xamarinmac20/_._",
+        "lib/xamarintvos10/_._",
+        "lib/xamarinwatchos10/_._",
+        "ref/MonoAndroid10/_._",
+        "ref/MonoTouch10/_._",
+        "ref/net461/System.Drawing.Common.dll",
+        "ref/netcoreapp3.0/System.Drawing.Common.dll",
+        "ref/netcoreapp3.0/System.Drawing.Common.xml",
+        "ref/netstandard2.0/System.Drawing.Common.dll",
+        "ref/xamarinios10/_._",
+        "ref/xamarinmac20/_._",
+        "ref/xamarintvos10/_._",
+        "ref/xamarinwatchos10/_._",
+        "runtimes/unix/lib/netcoreapp2.0/System.Drawing.Common.dll",
+        "runtimes/unix/lib/netcoreapp3.0/System.Drawing.Common.dll",
+        "runtimes/unix/lib/netcoreapp3.0/System.Drawing.Common.xml",
+        "runtimes/win/lib/netcoreapp2.0/System.Drawing.Common.dll",
+        "runtimes/win/lib/netcoreapp3.0/System.Drawing.Common.dll",
+        "runtimes/win/lib/netcoreapp3.0/System.Drawing.Common.xml",
+        "system.drawing.common.4.7.0.nupkg.sha512",
+        "system.drawing.common.nuspec",
+        "useSharedDesignerContext.txt",
+        "version.txt"
+      ]
+    },
     "System.Dynamic.Runtime/4.3.0": {
       "sha512": "SNVi1E/vfWUAs/WYKhE9+qlS6KqK0YVhnlT0HQtr8pMIA8YX3lwy3uPMownDwdYISBdmAF/2holEIldVp85Wag==",
       "type": "package",
       "Microsoft.EntityFrameworkCore >= 2.2.0",
       "Microsoft.EntityFrameworkCore.SqlServer >= 2.2.0",
       "Microsoft.NETCore.App >= 2.2.0",
-      "Npgsql.EntityFrameworkCore.PostgreSQL >= 2.2.0"
+      "Npgsql.EntityFrameworkCore.PostgreSQL >= 2.2.0",
+      "System.Data.SQLite >= 1.0.113.1",
+      "System.Drawing.Common >= 4.7.0"
     ]
   },
   "packageFolders": {
           "Npgsql.EntityFrameworkCore.PostgreSQL": {
             "target": "Package",
             "version": "[2.2.0, )"
+          },
+          "System.Data.SQLite": {
+            "target": "Package",
+            "version": "[1.0.113.1, )"
+          },
+          "System.Drawing.Common": {
+            "target": "Package",
+            "version": "[4.7.0, )"
           }
         },
         "imports": [

ProRestaurant/obj/project.nuget.cache

 {
   "version": 2,
-  "dgSpecHash": "UKkCi2QfTZjSh7Mo0X5a3rAzjsBDnMmv390wbgjtgsJjh822kapoCSoPoj2ogBN40mGlTEqkNrv/q6FLyQUZhw==",
+  "dgSpecHash": "0J0rJ7jz4g1WAA6fvo+sC4zFuEM3V67QHc0Kx7Nyy0ep9xx2FB8NdqxEERsAlbcOf71VJmnIpE5N39cE2x52ZA==",
   "success": true,
   "projectFilePath": "C:\\Work\\Development\\ProRestaurant\\RestaurantSite_API\\ProRestaurant\\ProRestaurant.csproj",
   "expectedPackageFiles": [
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\microsoft.netcore.dotnetapphost\\2.2.0\\microsoft.netcore.dotnetapphost.2.2.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\microsoft.netcore.dotnethostpolicy\\2.2.0\\microsoft.netcore.dotnethostpolicy.2.2.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\microsoft.netcore.dotnethostresolver\\2.2.0\\microsoft.netcore.dotnethostresolver.2.2.0.nupkg.sha512",
-    "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\microsoft.netcore.platforms\\2.2.0\\microsoft.netcore.platforms.2.2.0.nupkg.sha512",
+    "C:\\Users\\georg\\.nuget\\packages\\microsoft.netcore.platforms\\3.1.0\\microsoft.netcore.platforms.3.1.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\microsoft.netcore.targets\\2.0.0\\microsoft.netcore.targets.2.0.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\microsoft.win32.registry\\4.5.0\\microsoft.win32.registry.4.5.0.nupkg.sha512",
+    "C:\\Users\\georg\\.nuget\\packages\\microsoft.win32.systemevents\\4.7.0\\microsoft.win32.systemevents.4.7.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\netstandard.library\\2.0.3\\netstandard.library.2.0.3.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\newtonsoft.json\\11.0.2\\newtonsoft.json.11.0.2.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\newtonsoft.json.bson\\1.0.1\\newtonsoft.json.bson.1.0.1.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.componentmodel.annotations\\4.5.0\\system.componentmodel.annotations.4.5.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.console\\4.3.0\\system.console.4.3.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.data.sqlclient\\4.6.0\\system.data.sqlclient.4.6.0.nupkg.sha512",
+    "C:\\Users\\georg\\.nuget\\packages\\system.data.sqlite\\1.0.113.1\\system.data.sqlite.1.0.113.1.nupkg.sha512",
+    "C:\\Users\\georg\\.nuget\\packages\\system.data.sqlite.core\\1.0.113.1\\system.data.sqlite.core.1.0.113.1.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.diagnostics.contracts\\4.3.0\\system.diagnostics.contracts.4.3.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.diagnostics.debug\\4.3.0\\system.diagnostics.debug.4.3.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.diagnostics.diagnosticsource\\4.5.0\\system.diagnostics.diagnosticsource.4.5.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.diagnostics.stacktrace\\4.3.0\\system.diagnostics.stacktrace.4.3.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.diagnostics.tools\\4.3.0\\system.diagnostics.tools.4.3.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.diagnostics.tracing\\4.3.0\\system.diagnostics.tracing.4.3.0.nupkg.sha512",
+    "C:\\Users\\georg\\.nuget\\packages\\system.drawing.common\\4.7.0\\system.drawing.common.4.7.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.dynamic.runtime\\4.3.0\\system.dynamic.runtime.4.3.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.globalization\\4.3.0\\system.globalization.4.3.0.nupkg.sha512",
     "C:\\Program Files\\dotnet\\sdk\\NuGetFallbackFolder\\system.globalization.calendars\\4.3.0\\system.globalization.calendars.4.3.0.nupkg.sha512",