Ported some code from Blazor version of project.

MultiShop/server/Controllers/PublicApiSettingsController.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Configuration;
+using MultiShop.Options;
+
+namespace MultiShop.Server.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class PublicApiSettingsController : ControllerBase
+    {
+        private IConfiguration configuration;
+        public PublicApiSettingsController(IConfiguration configuration)
+        {
+            this.configuration = configuration;
+        }
+
+        [HttpGet]
+        public IActionResult Get() {
+            return Ok(BuildPublicApiSettings());
+        }
+
+        private IReadOnlyDictionary<string, string> BuildPublicApiSettings() {
+            IdentificationOptions identificationOptions = configuration.GetSection(IdentificationOptions.Identification).Get<IdentificationOptions>();
+            return new Dictionary<string,string>() {
+                // Build dictionary containing options client should be aware of.
+                {"RegistrationEnabled", identificationOptions.RegistrationEnabled.ToString()}
+            };
+        }
+    }
+}

MultiShop/server/Controllers/UserConfigurationsController.cs

@@ -0,0 +1,82 @@
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using MultiShop.Data;
+using MultiShop.Models;
+using MultiShop.Shared.Models;
+
+namespace MultiShop.Server.Controllers
+{
+
+    [ApiController]
+    [Authorize]
+    [Route("api/[controller]")]
+    public class UserConfigurationsController : ControllerBase
+    {
+        private ILogger<UserConfigurationsController> logger;
+        private UserManager<ApplicationUser> userManager;
+        private ApplicationDbContext dbContext;
+        public UserConfigurationsController(UserManager<ApplicationUser> userManager, ApplicationDbContext dbContext, ILogger<UserConfigurationsController> logger)
+        {
+            this.userManager = userManager;
+            this.dbContext = dbContext;
+            this.logger = logger;
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetSearchOutline() {
+            ApplicationUser userModel = await userManager.GetUserAsync(User);
+            return Ok(userModel.SearchOutline);
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetResultsPreferences() {
+            ApplicationUser userModel = await userManager.GetUserAsync(User);
+            return Ok(userModel.ResultsPreferences);
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> GetApplicationPreferences() {
+            ApplicationUser userModel = await userManager.GetUserAsync(User);
+            logger.LogInformation(JsonSerializer.Serialize(userModel.ApplicationPreferences));
+            return Ok(userModel.ApplicationPreferences);
+        }
+
+        [HttpPut]
+        public async Task<IActionResult> PutSearchOutline(SearchOutline searchOutline) {
+            ApplicationUser userModel = await userManager.GetUserAsync(User);
+            if (userModel.SearchOutline.Id != searchOutline.Id || userModel.Id != searchOutline.ApplicationUserId) {
+                return BadRequest();
+            }
+            dbContext.Entry(userModel.SearchOutline).CurrentValues.SetValues(searchOutline);
+            await userManager.UpdateAsync(userModel);
+            return NoContent();
+        }
+
+        [HttpPut]
+        public async Task<IActionResult> PutResultsPreferences(ResultsPreferences resultsPreferences) {
+            ApplicationUser userModel = await userManager.GetUserAsync(User);
+            if (userModel.ResultsPreferences.Id != resultsPreferences.Id || userModel.Id != resultsPreferences.ApplicationUserId) {
+                return BadRequest();
+            }
+            dbContext.Entry(userModel.ResultsPreferences).CurrentValues.SetValues(resultsPreferences);
+            await userManager.UpdateAsync(userModel);
+            return NoContent();
+        }
+
+        [HttpPut]
+        public async Task<IActionResult> PutApplicationPreferences(ApplicationPreferences applicationPreferences) {
+            ApplicationUser userModel = await userManager.GetUserAsync(User);
+            logger.LogInformation(JsonSerializer.Serialize(applicationPreferences));
+            if (userModel.ApplicationPreferences.Id != applicationPreferences.Id || userModel.Id != applicationPreferences.ApplicationUserId) {
+                return BadRequest();
+            }
+            dbContext.Entry(userModel.ApplicationPreferences).CurrentValues.SetValues(applicationPreferences);
+            await userManager.UpdateAsync(userModel);
+            return NoContent();
+        }
+    }
+}

MultiShop/server/Controllers/WeatherForecastController.cs

@@ -8,9 +8,10 @@ using Microsoft.Extensions.Logging;
 
 namespace MultiShop.Controllers
 {
+    // TODO: Create new shop search controller.
     [Authorize]
     [ApiController]
-    [Route("[controller]")]
+    [Route("api/[controller]")]
     public class WeatherForecastController : ControllerBase
     {
         private static readonly string[] Summaries = new[]

MultiShop/server/Data/ApplicationDbContext.cs

@@ -7,6 +7,8 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore.ChangeTracking;
 
 namespace MultiShop.Data
 {
@@ -17,5 +19,33 @@ namespace MultiShop.Data
             IOptions<OperationalStoreOptions> operationalStoreOptions) : base(options, operationalStoreOptions)
         {
         }
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder) {
+            base.OnModelCreating(modelBuilder);
+            
+            modelBuilder.Entity<ResultsPreferences>()
+                .Property(e => e.Order)
+                .HasConversion(
+                    v => JsonSerializer.Serialize(v, null), 
+                    v => JsonSerializer.Deserialize<List<ResultsPreferences.Category>>(v, null), 
+                    new ValueComparer<IList<ResultsPreferences.Category>>(
+                        (a, b) => a.SequenceEqual(b),
+                        c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
+                        c => (IList<ResultsPreferences.Category>) c.ToList()
+                    )
+                );
+
+            modelBuilder.Entity<SearchOutline>()
+                .Property(e => e.ShopStates)
+                .HasConversion(
+                    v => JsonSerializer.Serialize(v, null), 
+                    v => JsonSerializer.Deserialize<SearchOutline.ShopToggler>(v, null),
+                    new ValueComparer<SearchOutline.ShopToggler>(
+                        (a, b) => a.Equals(b),
+                        c => c.GetHashCode(),
+                        c => c.Clone()
+                    )
+                );
+        }
     }
 }

MultiShop/server/Data/Migrations/20210712080053_InitialCreate.Designer.cs

@@ -1,86 +1,22 @@
 // <auto-generated />
 using System;
-using MultiShop.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MultiShop.Data;
 
 namespace MultiShop.Data.Migrations
 {
     [DbContext(typeof(ApplicationDbContext))]
-    [Migration("00000000000000_CreateIdentitySchema")]
+    [Migration("20210712080053_InitialCreate")]
-    partial class CreateIdentitySchema
+    partial class InitialCreate
     {
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "5.0.0-rc.1.20417.2");
+                .HasAnnotation("ProductVersion", "5.0.5");
-
-            modelBuilder.Entity("MultiShop.Models.ApplicationUser", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers");
-                });
 
             modelBuilder.Entity("IdentityServer4.EntityFramework.Entities.DeviceFlowCodes", b =>
                 {
@@ -317,6 +253,180 @@ namespace MultiShop.Data.Migrations
                     b.ToTable("AspNetUserTokens");
                 });
 
+            modelBuilder.Entity("MultiShop.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.ResultsPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Order")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId")
+                        .IsUnique();
+
+                    b.ToTable("ResultsPreferences");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.SearchOutline", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableMaxShippingFee")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableUpperPrice")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnknownPurchaseCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnknownRatingCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnknownShipping")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnrated")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LowerPrice")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxResults")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxShippingFee")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MinPurchases")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<float>("MinRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<int>("MinReviews")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ShopStates")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UpperPrice")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId")
+                        .IsUnique();
+
+                    b.ToTable("SearchOutline");
+                });
+
+            modelBuilder.Entity("MultiShop.Shared.Models.ApplicationPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("CacheCommonSearches")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DarkMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableSearchHistory")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId")
+                        .IsUnique();
+
+                    b.ToTable("ApplicationPreferences");
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
@@ -367,6 +477,39 @@ namespace MultiShop.Data.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
                 });
+
+            modelBuilder.Entity("MultiShop.Models.ResultsPreferences", b =>
+                {
+                    b.HasOne("MultiShop.Models.ApplicationUser", null)
+                        .WithOne("ResultsPreferences")
+                        .HasForeignKey("MultiShop.Models.ResultsPreferences", "ApplicationUserId");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.SearchOutline", b =>
+                {
+                    b.HasOne("MultiShop.Models.ApplicationUser", null)
+                        .WithOne("SearchOutline")
+                        .HasForeignKey("MultiShop.Models.SearchOutline", "ApplicationUserId");
+                });
+
+            modelBuilder.Entity("MultiShop.Shared.Models.ApplicationPreferences", b =>
+                {
+                    b.HasOne("MultiShop.Models.ApplicationUser", null)
+                        .WithOne("ApplicationPreferences")
+                        .HasForeignKey("MultiShop.Shared.Models.ApplicationPreferences", "ApplicationUserId");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.ApplicationUser", b =>
+                {
+                    b.Navigation("ApplicationPreferences")
+                        .IsRequired();
+
+                    b.Navigation("ResultsPreferences")
+                        .IsRequired();
+
+                    b.Navigation("SearchOutline")
+                        .IsRequired();
+                });
 #pragma warning restore 612, 618
         }
     }

MultiShop/server/Data/Migrations/20210712080053_InitialCreate.cs

@@ -3,7 +3,7 @@ using Microsoft.EntityFrameworkCore.Migrations;
 
 namespace MultiShop.Data.Migrations
 {
-    public partial class CreateIdentitySchema : Migration
+    public partial class InitialCreate : Migration
     {
         protected override void Up(MigrationBuilder migrationBuilder)
         {
@@ -106,6 +106,28 @@ namespace MultiShop.Data.Migrations
                         onDelete: ReferentialAction.Cascade);
                 });
 
+            migrationBuilder.CreateTable(
+                name: "ApplicationPreferences",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    ApplicationUserId = table.Column<string>(type: "TEXT", nullable: true),
+                    DarkMode = table.Column<bool>(type: "INTEGER", nullable: false),
+                    CacheCommonSearches = table.Column<bool>(type: "INTEGER", nullable: false),
+                    EnableSearchHistory = table.Column<bool>(type: "INTEGER", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ApplicationPreferences", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ApplicationPreferences_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
             migrationBuilder.CreateTable(
                 name: "AspNetUserClaims",
                 columns: table => new
@@ -191,6 +213,66 @@ namespace MultiShop.Data.Migrations
                         onDelete: ReferentialAction.Cascade);
                 });
 
+            migrationBuilder.CreateTable(
+                name: "ResultsPreferences",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    ApplicationUserId = table.Column<string>(type: "TEXT", nullable: true),
+                    Order = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ResultsPreferences", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_ResultsPreferences_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "SearchOutline",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    ApplicationUserId = table.Column<string>(type: "TEXT", nullable: true),
+                    Currency = table.Column<int>(type: "INTEGER", nullable: false),
+                    MaxResults = table.Column<int>(type: "INTEGER", nullable: false),
+                    MinRating = table.Column<float>(type: "REAL", nullable: false),
+                    KeepUnrated = table.Column<bool>(type: "INTEGER", nullable: false),
+                    EnableUpperPrice = table.Column<bool>(type: "INTEGER", nullable: false),
+                    UpperPrice = table.Column<int>(type: "INTEGER", nullable: false),
+                    LowerPrice = table.Column<int>(type: "INTEGER", nullable: false),
+                    MinPurchases = table.Column<int>(type: "INTEGER", nullable: false),
+                    KeepUnknownPurchaseCount = table.Column<bool>(type: "INTEGER", nullable: false),
+                    MinReviews = table.Column<int>(type: "INTEGER", nullable: false),
+                    KeepUnknownRatingCount = table.Column<bool>(type: "INTEGER", nullable: false),
+                    EnableMaxShippingFee = table.Column<bool>(type: "INTEGER", nullable: false),
+                    MaxShippingFee = table.Column<int>(type: "INTEGER", nullable: false),
+                    KeepUnknownShipping = table.Column<bool>(type: "INTEGER", nullable: false),
+                    ShopStates = table.Column<string>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SearchOutline", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_SearchOutline_AspNetUsers_ApplicationUserId",
+                        column: x => x.ApplicationUserId,
+                        principalTable: "AspNetUsers",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ApplicationPreferences_ApplicationUserId",
+                table: "ApplicationPreferences",
+                column: "ApplicationUserId",
+                unique: true);
+
             migrationBuilder.CreateIndex(
                 name: "IX_AspNetRoleClaims_RoleId",
                 table: "AspNetRoleClaims",
@@ -253,10 +335,25 @@ namespace MultiShop.Data.Migrations
                 name: "IX_PersistedGrants_SubjectId_SessionId_Type",
                 table: "PersistedGrants",
                 columns: new[] { "SubjectId", "SessionId", "Type" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ResultsPreferences_ApplicationUserId",
+                table: "ResultsPreferences",
+                column: "ApplicationUserId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SearchOutline_ApplicationUserId",
+                table: "SearchOutline",
+                column: "ApplicationUserId",
+                unique: true);
         }
 
         protected override void Down(MigrationBuilder migrationBuilder)
         {
+            migrationBuilder.DropTable(
+                name: "ApplicationPreferences");
+
             migrationBuilder.DropTable(
                 name: "AspNetRoleClaims");
 
@@ -278,6 +375,12 @@ namespace MultiShop.Data.Migrations
             migrationBuilder.DropTable(
                 name: "PersistedGrants");
 
+            migrationBuilder.DropTable(
+                name: "ResultsPreferences");
+
+            migrationBuilder.DropTable(
+                name: "SearchOutline");
+
             migrationBuilder.DropTable(
                 name: "AspNetRoles");
 

MultiShop/server/Data/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -1,9 +1,9 @@
 // <auto-generated />
 using System;
-using MultiShop.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using MultiShop.Data;
 
 namespace MultiShop.Data.Migrations
 {
@@ -14,71 +14,7 @@ namespace MultiShop.Data.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "5.0.0-rc.1.20417.2");
+                .HasAnnotation("ProductVersion", "5.0.5");
-
-            modelBuilder.Entity("MultiShop.Models.ApplicationUser", b =>
-                {
-                    b.Property<string>("Id")
-                        .HasColumnType("TEXT");
-
-                    b.Property<int>("AccessFailedCount")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("EmailConfirmed")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<bool>("LockoutEnabled")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<DateTimeOffset?>("LockoutEnd")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("NormalizedEmail")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("NormalizedUserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("PasswordHash")
-                        .HasColumnType("TEXT");
-
-                    b.Property<string>("PhoneNumber")
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("PhoneNumberConfirmed")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("SecurityStamp")
-                        .HasColumnType("TEXT");
-
-                    b.Property<bool>("TwoFactorEnabled")
-                        .HasColumnType("INTEGER");
-
-                    b.Property<string>("UserName")
-                        .HasMaxLength(256)
-                        .HasColumnType("TEXT");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("NormalizedEmail")
-                        .HasDatabaseName("EmailIndex");
-
-                    b.HasIndex("NormalizedUserName")
-                        .IsUnique()
-                        .HasDatabaseName("UserNameIndex");
-
-                    b.ToTable("AspNetUsers");
-                });
 
             modelBuilder.Entity("IdentityServer4.EntityFramework.Entities.DeviceFlowCodes", b =>
                 {
@@ -315,6 +251,180 @@ namespace MultiShop.Data.Migrations
                     b.ToTable("AspNetUserTokens");
                 });
 
+            modelBuilder.Entity("MultiShop.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.ResultsPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Order")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId")
+                        .IsUnique();
+
+                    b.ToTable("ResultsPreferences");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.SearchOutline", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableMaxShippingFee")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableUpperPrice")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnknownPurchaseCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnknownRatingCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnknownShipping")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepUnrated")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LowerPrice")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxResults")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxShippingFee")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MinPurchases")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<float>("MinRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<int>("MinReviews")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ShopStates")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("UpperPrice")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId")
+                        .IsUnique();
+
+                    b.ToTable("SearchOutline");
+                });
+
+            modelBuilder.Entity("MultiShop.Shared.Models.ApplicationPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("CacheCommonSearches")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DarkMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableSearchHistory")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId")
+                        .IsUnique();
+
+                    b.ToTable("ApplicationPreferences");
+                });
+
             modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
@@ -365,6 +475,39 @@ namespace MultiShop.Data.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
                 });
+
+            modelBuilder.Entity("MultiShop.Models.ResultsPreferences", b =>
+                {
+                    b.HasOne("MultiShop.Models.ApplicationUser", null)
+                        .WithOne("ResultsPreferences")
+                        .HasForeignKey("MultiShop.Models.ResultsPreferences", "ApplicationUserId");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.SearchOutline", b =>
+                {
+                    b.HasOne("MultiShop.Models.ApplicationUser", null)
+                        .WithOne("SearchOutline")
+                        .HasForeignKey("MultiShop.Models.SearchOutline", "ApplicationUserId");
+                });
+
+            modelBuilder.Entity("MultiShop.Shared.Models.ApplicationPreferences", b =>
+                {
+                    b.HasOne("MultiShop.Models.ApplicationUser", null)
+                        .WithOne("ApplicationPreferences")
+                        .HasForeignKey("MultiShop.Shared.Models.ApplicationPreferences", "ApplicationUserId");
+                });
+
+            modelBuilder.Entity("MultiShop.Models.ApplicationUser", b =>
+                {
+                    b.Navigation("ApplicationPreferences")
+                        .IsRequired();
+
+                    b.Navigation("ResultsPreferences")
+                        .IsRequired();
+
+                    b.Navigation("SearchOutline")
+                        .IsRequired();
+                });
 #pragma warning restore 612, 618
         }
     }

MultiShop/server/Models/ApplicationPreferences.cs

@@ -0,0 +1,15 @@
+namespace MultiShop.Shared.Models
+{
+    public class ApplicationPreferences
+    {
+        public int Id { get; set; }
+        
+        public string ApplicationUserId { get; set; }
+
+        public bool DarkMode { get; set; }
+
+        public bool CacheCommonSearches { get; set; } = true;
+
+        public bool EnableSearchHistory { get; set; } = true;
+    }
+}

MultiShop/server/Models/ApplicationUser.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.Identity;
+using MultiShop.Shared.Models;
 using System;
 using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -8,5 +10,13 @@ namespace MultiShop.Models
 {
     public class ApplicationUser : IdentityUser
     {
+        [Required]
+        public virtual SearchOutline SearchOutline { get; private set; } = new SearchOutline();
+
+        [Required]
+        public virtual ResultsPreferences ResultsPreferences { get; private set; } = new ResultsPreferences();
+
+        [Required]
+        public virtual ApplicationPreferences ApplicationPreferences {get; private set; } = new ApplicationPreferences();
     }
 }

MultiShop/server/Models/ResultsPreferences.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Text.Json;
+
+namespace MultiShop.Models
+{
+    public class ResultsPreferences
+    {
+        public int Id { get; set; }
+        public string ApplicationUserId { get; set; }
+        
+        [Required]
+        public IList<Category> Order { get; set; }
+
+        public ResultsPreferences()
+        {
+            Order = new List<Category>(Enum.GetValues<Category>().Length);
+            foreach (Category category in Enum.GetValues<Category>())
+            {
+                Order.Add(category);
+            }
+        }
+
+        public enum Category
+        {
+            RatingPriceRatio,
+            Reviews,
+            Purchases,
+            Price,
+        }
+    }
+}

MultiShop/server/Models/SearchOutline.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using MultiShop.Shop.Framework;
+
+namespace MultiShop.Models
+{
+    public class SearchOutline
+    {
+        public int Id { get; set; }
+        public string ApplicationUserId { get; set; }
+
+        public Currency Currency { get; set; } = Currency.CAD;
+        public int MaxResults { get; set; } = 100;
+        public float MinRating { get; set; } = 0.8f;
+        public bool KeepUnrated { get; set; } = true;
+        public bool EnableUpperPrice { get; set; } = false;
+        private int _upperPrice;
+
+        public int UpperPrice
+        {
+            get
+            {
+                return _upperPrice;
+            }
+            set
+            {
+                if (EnableUpperPrice) _upperPrice = value;
+            }
+        }
+        public int LowerPrice { get; set; }
+        public int MinPurchases { get; set; }
+        public bool KeepUnknownPurchaseCount { get; set; } = true;
+        public int MinReviews { get; set; }
+        public bool KeepUnknownRatingCount { get; set; } = true;
+        public bool EnableMaxShippingFee { get; set; }
+        private int _maxShippingFee;
+
+        public int MaxShippingFee
+        {
+            get
+            {
+                return _maxShippingFee;
+            }
+            set
+            {
+                if (EnableMaxShippingFee) _maxShippingFee = value;
+            }
+        }
+        public bool KeepUnknownShipping { get; set; } = true;
+
+        [Required]
+        public ShopToggler ShopStates { get; set; } = new ShopToggler();
+
+        public sealed class ShopToggler : HashSet<string>
+        {
+            public int TotalShops { get; set; }
+            public bool this[string name] {
+                get {
+                    return !this.Contains(name);
+                }
+                set {
+                    if (value == false && TotalShops - Count <= 1) return;
+                    if (value)
+                    {
+                        this.Remove(name);
+                    }
+                    else
+                    {
+                        this.Add(name);
+                    }
+                }
+            }
+
+            public ShopToggler Clone() {
+                ShopToggler clone = new ShopToggler();
+                clone.Union(this);
+                return clone;
+            }
+
+            public bool IsShopToggleable(string shop)
+            {
+                return (!Contains(shop) && TotalShops - Count > 1) || Contains(shop);
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null || GetType() != obj.GetType())
+            {
+                return false;
+            }
+            SearchOutline other = (SearchOutline) obj;
+            return 
+                Id == other.Id && 
+                Currency == other.Currency && 
+                MaxResults == other.MaxResults && 
+                MinRating == other.MinRating && 
+                KeepUnrated == other.KeepUnrated && 
+                EnableUpperPrice == other.EnableUpperPrice && 
+                UpperPrice == other.UpperPrice && 
+                LowerPrice == other.LowerPrice && 
+                MinPurchases == other.MinPurchases && 
+                KeepUnknownPurchaseCount == other.KeepUnknownPurchaseCount && 
+                MinReviews == other.MinReviews && 
+                KeepUnknownRatingCount == other.KeepUnknownRatingCount && 
+                EnableMaxShippingFee == other.EnableMaxShippingFee && 
+                MaxShippingFee == other.MaxShippingFee && 
+                KeepUnknownShipping == other.KeepUnknownShipping && 
+                ShopStates.Equals(other.ShopStates);
+        }
+        
+        public override int GetHashCode()
+        {
+            return Id;
+        }
+
+        public SearchOutline DeepCopy() {
+            SearchOutline profile = (SearchOutline)MemberwiseClone();
+            profile.ShopStates = ShopStates.Clone();
+            return profile;
+        }
+    }
+}

MultiShop/server/MultiShop.csproj

@@ -32,6 +32,9 @@
     <None Remove="$(SpaRoot)**" />
     <None Include="$(SpaRoot)**" Exclude="$(SpaRoot)node_modules\**" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\MultiShop-Modules\MultiShop.Shop\Framework\MultiShop.Shop.Framework.csproj" />
+  </ItemGroup>
 
   <Target Name="DebugEnsureNodeEnv" BeforeTargets="Build" Condition=" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)node_modules') ">
     <!-- Ensure Node.js is installed -->

MultiShop/server/appsettings.json

@@ -9,5 +9,8 @@
       "Microsoft.Hosting.Lifetime": "Information"
     }
   },
+  "Identification": {
+    "RegistrationEnabled": true
+  },
   "AllowedHosts": "*"
 }

MultiShop/server/options/IdentificationOptions.cs

@@ -0,0 +1,8 @@
+namespace MultiShop.Options
+{
+    public class IdentificationOptions
+    {
+        public const string Identification = "Identification";
+        public bool RegistrationEnabled  { get; set; }
+    }
+}