Revert "Added a check for the DB and a delay at start up if the database is not available (#148)"

This reverts commit f9d6cc4bdc.

.devcontainer/Dockerfile

@@ -1,6 +0,0 @@
-FROM mcr.microsoft.com/devcontainers/dotnet:1-8.0-bookworm
-
-RUN apt-get update && apt-get install -y p7zip-full
-RUN mkdir -p /workspace/gaseous-server/wwwroot/emulators/EmulatorJS
-RUN wget https://cdn.emulatorjs.org/releases/4.0.12.7z
-RUN 7z x -y -o/workspace/gaseous-server/wwwroot/emulators/EmulatorJS 4.0.12.7z

.devcontainer/devcontainer.json

@@ -1,48 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/dotnet
-{
-	"name": "C# (.NET)",
-	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-	//"image": "mcr.microsoft.com/devcontainers/dotnet:1-8.0-bookworm",
-	"dockerComposeFile": "docker-compose.yml",
-	"service": "development",
-	"workspaceFolder": "/workspace",
-
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	// "features": {},
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	"forwardPorts": [5198],
-	"portsAttributes": {
-			"5198": {
-				"protocol": "http"
-			}
-	},
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-	"postCreateCommand": "dotnet restore",
-
-	// Configure tool-specific properties.
-	"customizations": {
-		"vscode": {
-			"extensions": [
-				"cweijan.vscode-mysql-client2",
-				"ms-dotnettools.csdevkit",
-				"ms-dotnettools.csharp",
-				"ms-dotnettools.vscode-dotnet-runtime",
-				"ecmel.vscode-html-css",
-				"github.vscode-github-actions",
-				"GitHub.vscode-pull-request-github",
-				"AndersEAndersen.html-class-suggestions",
-				"george-alisson.html-preview-vscode",
-				"ms-dotnettools.vscodeintellicode-csharp",
-				"Zignd.html-css-class-completion",
-				"PWABuilder.pwa-studio",
-				"ms-azuretools.vscode-docker"
-			]
-		}
-	}
-
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
-}

.devcontainer/docker-compose.yml

@@ -1,25 +0,0 @@
-services:
-  development:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    volumes:
-      - ..:/workspace
-    stdin_open: true
-    environment:
-      - TZ=Australia/Sydney
-      - dbhost=${DATABASE_HOST}
-      - dbuser=${DATABASE_USER}
-      - dbpass=${DATABASE_PASSWORD}
-      - igdbclientid=${IGDB_CLIENT_ID}
-      - igdbclientsecret=${IGDB_CLIENT_SECRET}
-  mariadb:
-    hostname: mariadb
-    image: mariadb:latest
-    ports:
-      - 3306:3306
-    environment:
-      - MARIADB_ROOT_PASSWORD=${DATABASE_PASSWORD}
-      - MARIADB_DATABASE=${DATABASE_DB}
-      - MARIADB_USER=${DATABASE_USER}
-      - MARIADB_PASSWORD=${DATABASE_PASSWORD}

.gitea/workflows/registry.yml

@@ -1,51 +0,0 @@
-name: release-tag
-on:
-  push:
-    branches:
-      - 'main'
-jobs:
-  release-image:
-    runs-on: ubuntu-latest
-    env:
-      DOCKER_ORG: sendnrw
-      DOCKER_LATEST: latest
-      RUNNER_TOOL_CACHE: /toolcache
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker BuildX
-        uses: docker/setup-buildx-action@v2
-        with: # replace it with your local IP
-          config-inline: |
-            [registry."git.send.nrw"] 
-              http = true
-              insecure = true                                                
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v2
-        with:
-          registry: git.send.nrw # replace it with your local IP
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-          
-      - name: Get Meta
-        id: meta
-        run: |
-          echo REPO_NAME=$(echo ${GITHUB_REPOSITORY} | awk -F"/" '{print $2}') >> $GITHUB_OUTPUT
-          echo REPO_VERSION=$(git describe --tags --always | sed 's/^v//') >> $GITHUB_OUTPUT                                              
-
-      - name: Build and push
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          file: ./build/Dockerfile
-          platforms: |
-            linux/amd64                                                           
-          push: true
-          tags: | # replace it with your local IP and tags
-            git.send.nrw/${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ steps.meta.outputs.REPO_VERSION }}
-            git.send.nrw/${{ env.DOCKER_ORG }}/${{ steps.meta.outputs.REPO_NAME }}:${{ env.DOCKER_LATEST }}

.github/dependabot.yml

@@ -9,7 +9,9 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "weekly"
-  - package-ecosystem: "devcontainers"
+  - package-ecosystem: "gitsubmodule"
     directory: "/"
+    allow:
+      - dependency-name: "gaseous-server/wwwroot/emulators/EmulatorJS"
     schedule:
       interval: "weekly"

.github/release.yml

@@ -1,19 +0,0 @@
-changelog:
-  categories:
-    - title: What's New
-      labels:
-        - '*'
-      exclude:
-        labels:
-          - note
-          - bug
-          - dependencies
-    - title: Notes
-      labels:
-        - note
-    - title: Bug Fixes
-      labels:
-        - bug
-    - title: Dependencies
-      labels:
-        - dependencies

.github/workflows/BuildDockerOnTag-Prerelease.yml

@@ -9,14 +9,9 @@ on:
 jobs:
   docker:
     runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-      attestations: write
-      id-token: write
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           submodules: 'true'
       - name: Install dotnet tool
@@ -26,37 +21,18 @@ jobs:
       - name: Sign in to Nuget
         run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Login to GitHub Package Registry
+      - name: Build and push
-        uses: docker/login-action@v3
+        uses: docker/build-push-action@v4
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build and push standard image
-        uses: docker/build-push-action@v6
         with:
           context: .
-          file: ./build/Dockerfile
+          platforms: linux/amd64 #,linux/arm64
-          platforms: linux/amd64,linux/arm64
           push: true
-          tags: |
+          tags: gaseousgames/gaseousserver:${{ github.ref_name}}
-            gaseousgames/gaseousserver:${{ github.ref_name}}
-            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}
-      - name: Build and push image with embedded mariadb
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./build/Dockerfile-EmbeddedDB
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: |
-            gaseousgames/gaseousserver:${{ github.ref_name}}-embeddeddb
-            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}-embeddeddb

.github/workflows/BuildDockerOnTag-Release.yml

@@ -8,14 +8,9 @@ on:
 jobs:
   docker:
     runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-      attestations: write
-      id-token: write
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
         with:
           submodules: 'true'
       - name: Install dotnet tool
@@ -25,39 +20,18 @@ jobs:
       - name: Sign in to Nuget
         run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v2
       - name: Login to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Login to GitHub Package Registry
+      - name: Build and push
-        uses: docker/login-action@v3
+        uses: docker/build-push-action@v4
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build and push standard image
-        uses: docker/build-push-action@v6
         with:
           context: .
-          file: ./build/Dockerfile
+          platforms: linux/amd64 #,linux/arm64
-          platforms: linux/amd64,linux/arm64
           push: true
-          tags: |
+          tags: gaseousgames/gaseousserver:latest,gaseousgames/gaseousserver:${{ github.ref_name}}
-            gaseousgames/gaseousserver:latest
-            gaseousgames/gaseousserver:${{ github.ref_name}}
-            ghcr.io/gaseous-project/gaseousserver:latest
-            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}
-      - name: Build and push image with embedded mariadb
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./build/Dockerfile-EmbeddedDB
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: |
-            gaseousgames/gaseousserver:${{ github.ref_name}}-embeddeddb
-            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}-embeddeddb

.github/workflows/BuildNightly.yml

@@ -1,61 +0,0 @@
-name: Build Nightly Docker Image
-
-on:
-  schedule:
-    - cron: '15 4 * * *'
-  workflow_dispatch:
-
-jobs:
-  docker:
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-      contents: read
-      attestations: write
-      id-token: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          submodules: 'true'
-      - name: Install dotnet tool
-        run: dotnet tool install -g dotnetCampus.TagToVersion
-      - name: Set tag to version  
-        run: dotnet TagToVersion -t 0.0.0-nightly
-      - name: Sign in to Nuget
-        run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Login to GitHub Package Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build and push standard image
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./build/Dockerfile
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: |
-            gaseousgames/gaseousserver:nightly
-            ghcr.io/gaseous-project/gaseousserver:nightly
-      - name: Build and push image with embedded mariadb
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          file: ./build/Dockerfile-EmbeddedDB
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: |
-            gaseousgames/gaseousserver:nightly-embeddeddb
-            ghcr.io/gaseous-project/gaseousserver:nightly-embeddeddb

.github/workflows/BuildOnTestBranch.yml

@@ -1,36 +0,0 @@
-name: Build test branch
-
-on:
-  push:
-    branches: [test]
-
-jobs:
-  docker:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-        with:
-          submodules: 'true'
-      - name: Install dotnet tool
-        run: dotnet tool install -g dotnetCampus.TagToVersion
-      - name: Set tag to version  
-        run: dotnet TagToVersion -t 0.0.1
-      - name: Sign in to Nuget
-        run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: gaseousgames/test:latest

.github/workflows/codeql.yml

@@ -0,0 +1,85 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "main", "branch-v*.*.*" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "main" ]
+  schedule:
+    - cron: '21 11 * * 2'
+
+jobs:
+  analyze:
+    name: Analyze
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners
+    # Consider using larger runners for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'csharp', 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby', 'swift' ]
+        # Use only 'java' to analyze code written in Java, Kotlin or both
+        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+      
+    - name: Sign in to Nuget
+      run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
+        
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+
+    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #     echo "Run, Build Application using script"
+    #     ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/dotnet.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 8.0.x
+          dotnet-version: 7.0.x
       - name: Sign in to Nuget
         run: dotnet nuget add source --username michael-j-green --password ${{ secrets.NUGETKEY }} --store-password-in-clear-text --name github "https://nuget.pkg.github.com/gaseous-project/index.json"
       - name: Restore dependencies

.gitignore

@@ -403,8 +403,3 @@ ASALocalRun/
 
 # Local History for Visual Studio
 .localhistory/
-gaseous-server/.DS_Store
-gaseous-server/wwwroot/.DS_Store
-gaseous-server/wwwroot/emulators/EmulatorJS
-.devcontainer/.env
-.mono/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "gaseous-server/wwwroot/emulators/EmulatorJS"]
+	path = gaseous-server/wwwroot/emulators/EmulatorJS
+	url = https://github.com/EmulatorJS/EmulatorJS.git

.vscode/launch.json

@@ -10,22 +10,21 @@
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/gaseous-server/bin/Debug/net8.0/gaseous-server.dll",
+            "program": "${workspaceFolder}/gaseous-server/bin/Debug/net7.0/gaseous-server.dll",
             "args": [],
             "cwd": "${workspaceFolder}/gaseous-server",
             "stopAtEntry": false,
             // Enable launching a web browser when ASP.NET Core starts. For more information: https://aka.ms/VSCode-CS-LaunchJson-WebBrowser
             "serverReadyAction": {
                 "action": "openExternally",
-                "pattern": "\\bNow listening on:\\s+(http?://\\S+)"
+                "pattern": "\\bNow listening on:\\s+(https?://\\S+)"
             },
             "env": {
                 "ASPNETCORE_ENVIRONMENT": "Development"
             },
             "sourceFileMap": {
                 "/Views": "${workspaceFolder}/Views"
-            },
+            }
-            "enableStepFiltering": false
         },
         {
             "name": ".NET Core Attach",

Dockerfile

@@ -0,0 +1,16 @@
+FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build-env
+WORKDIR /App
+EXPOSE 80
+
+# Copy everything
+COPY . ./
+# Restore as distinct layers
+RUN dotnet restore "gaseous-server/gaseous-server.csproj"
+# Build and publish a release
+RUN dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained false -c Release -o out
+
+# Build runtime image
+FROM mcr.microsoft.com/dotnet/aspnet:7.0
+WORKDIR /App
+COPY --from=build-env /App/out .
+ENTRYPOINT ["dotnet", "gaseous-server.dll"]

Gaseous.sln

@@ -3,7 +3,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 25.0.1704.4
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "gaseous-server", "gaseous-server\gaseous-server.csproj", "{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-tools", "gaseous-tools\gaseous-tools.csproj", "{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-server", "gaseous-server\gaseous-server.csproj", "{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{17FA6F12-8532-420C-9489-CB8FDE42137C}"
 	ProjectSection(SolutionItems) = preProject
@@ -21,30 +23,40 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "screenshots", "screenshots"
 		screenshots\Game.png = screenshots\Game.png
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-cli", "gaseous-cli\gaseous-cli.csproj", "{419CC4E4-8932-4E4A-B027-5521AA0CBA85}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{08699C93-15CD-4E39-9053-D3C8056CE938}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{08699C93-15CD-4E39-9053-D3C8056CE938}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{08699C93-15CD-4E39-9053-D3C8056CE938}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{08699C93-15CD-4E39-9053-D3C8056CE938}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Release|Any CPU.Build.0 = Release|Any CPU
-		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{F1A847C7-57BC-4DA9-8F83-CD060A7F5122} = {17FA6F12-8532-420C-9489-CB8FDE42137C}
-	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {979BF092-AFBC-4F19-B55F-32E73959BD1A}
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{F1A847C7-57BC-4DA9-8F83-CD060A7F5122} = {17FA6F12-8532-420C-9489-CB8FDE42137C}
+	EndGlobalSection
 EndGlobal

LICENSE

@@ -1,5 +1,5 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
+                       Version 3, 29 June 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
@@ -7,15 +7,17 @@
 
                             Preamble
 
-  The GNU Affero General Public License is a free, copyleft license for
+  The GNU General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
+software and other kinds of works.
-cooperation with the community in the case of network server software.
 
   The licenses for most software and other practical works are designed
 to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
+the GNU General Public License is intended to guarantee your freedom to
 share and change all versions of a program--to make sure it remains free
-software for all its users.
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
 
   When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
@@ -24,34 +26,44 @@ them if you wish), that you receive source code or can get it if you
 want it, that you can change the software or use pieces of it in new
 free programs, and that you know you can do these things.
 
-  Developers that use our General Public Licenses protect your rights
+  To protect your rights, we need to prevent others from denying you
-with two steps: (1) assert copyright on the software, and (2) offer
+these rights or asking you to surrender the rights.  Therefore, you have
-you this License which gives you legal permission to copy, distribute
+certain responsibilities if you distribute copies of the software, or if
-and/or modify the software.
+you modify it: responsibilities to respect the freedom of others.
 
-  A secondary benefit of defending all users' freedom is that
+  For example, if you distribute copies of such a program, whether
-improvements made in alternate versions of the program, if they
+gratis or for a fee, you must pass on to the recipients the same
-receive widespread use, become available for other developers to
+freedoms that you received.  You must make sure that they, too, receive
-incorporate.  Many developers of free software are heartened and
+or can get the source code.  And you must show them these terms so they
-encouraged by the resulting cooperation.  However, in the case of
+know their rights.
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
 
-  The GNU Affero General Public License is designed specifically to
+  Developers that use the GNU GPL protect your rights with two steps:
-ensure that, in such cases, the modified source code becomes available
+(1) assert copyright on the software, and (2) offer you this License
-to the community.  It requires the operator of a network server to
+giving you legal permission to copy, distribute and/or modify it.
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
 
-  An older license, called the Affero General Public License and
+  For the developers' and authors' protection, the GPL clearly explains
-published by Affero, was designed to accomplish similar goals.  This is
+that there is no warranty for this free software.  For both users' and
-a different license, not a version of the Affero GPL, but Affero has
+authors' sake, the GPL requires that modified versions be marked as
-released a new version of the Affero GPL which permits relicensing under
+changed, so that their problems will not be attributed erroneously to
-this license.
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
@@ -60,7 +72,7 @@ modification follow.
 
   0. Definitions.
 
-  "This License" refers to version 3 of the GNU Affero General Public License.
+  "This License" refers to version 3 of the GNU General Public License.
 
   "Copyright" also means copyright-like laws that apply to other kinds of
 works, such as semiconductor masks.
@@ -537,45 +549,35 @@ to collect a royalty for further conveying from those to whom you convey
 the Program, the only way you could satisfy both those terms and this
 License would be to refrain entirely from conveying the Program.
 
-  13. Remote Network Interaction; Use with the GNU General Public License.
+  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
 
   Notwithstanding any other provision of this License, you have
 permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
+under version 3 of the GNU Affero General Public License into a single
 combined work, and to convey the resulting work.  The terms of this
 License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
+but the special requirements of the GNU Affero General Public License,
-3 of the GNU General Public License.
+section 13, concerning interaction through a network will apply to the
+combination as such.
 
   14. Revised Versions of this License.
 
   The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
+the GNU General Public License from time to time.  Such new versions will
-will be similar in spirit to the present version, but may differ in detail to
+be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 
   Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
+Program specifies that a certain numbered version of the GNU General
 Public License "or any later version" applies to it, you have the
 option of following the terms and conditions either of that numbered
 version or of any later version published by the Free Software
 Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
+GNU General Public License, you may choose any version ever published
 by the Free Software Foundation.
 
   If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
+versions of the GNU General Public License can be used, that proxy's
 public statement of acceptance of a version permanently authorizes you
 to choose that version for the Program.
 
@@ -629,33 +631,44 @@ to attach them to the start of each source file to most effectively
 state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
-    <one line to give the program's name and a brief idea of what it does.>
+    Gaseous
-    Copyright (C) <year>  <name of author>
+    Copyright (C) 2023  Gaseous
 
     This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
+    it under the terms of the GNU General Public License as published by
-    by the Free Software Foundation, either version 3 of the License, or
+    the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
+    GNU General Public License for more details.
 
-    You should have received a copy of the GNU Affero General Public License
+    You should have received a copy of the GNU General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
-  If your software can interact with users remotely through a computer
+  If the program does terminal interaction, make it output a short
-network, you should also make sure that it provides a way for users to
+notice like this when it starts in an interactive mode:
-get its source.  For example, if your program is a web application, its
+
-interface could display a "Source" link that leads users to an archive
+    <program>  Copyright (C) 2023  Gaseous
-of the code.  There are many ways you could offer source, and different
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-solutions will be better for different programs; see section 13 for the
+    This is free software, and you are welcome to redistribute it
-specific requirements.
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
 
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
+For more information on this, and how to apply and follow the GNU GPL, see
 <https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.MD

@@ -1,42 +1,193 @@
-[![.NET](https://github.com/gaseous-project/gaseous-server/actions/workflows/dotnet.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/dotnet.yml) [![Nightly](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildNightly.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildNightly.yml) [![Build Release Docker Image](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildDockerOnTag-Release.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildDockerOnTag-Release.yml)
+# Gaseous Server
-# <img src="./logo.png" height="28" style="float: right;" /> Gaseous Server
 
-This is the server for the Gaseous system. It offers ROM and title management, as well as some basic in browser emulation of those ROMs.
+This is the server for the Gaseous system. It offers ROM and title management, as well as some basic in browser emulation of those ROM's.
 
-Version 1.7.0 and later contain user authentication, and can be exposed to the internet. However, it is recommended to not expose the server to the internet if you're not actively using it remotely, or if you have alternative means to access it remotely like a VPN.
+## Warning
 
-While we do our best to stay on top of server security, if you expose the server to the internet **you do so at your own risk**.
+This project is currently not suitable for being exposed to the internet.
+1. there is currently no authentication support, meaning anyone could trash your library
+2. the server has not been hardened for exposure to the internet - so there maybe unknown vulnerabilities
+
+If you expose the server to the internet, **you do so at your own risk**.
 
 ## Screenshots
-![Library](./gaseous-server/wwwroot/screenshots/Library.png)
+![Library](./screenshots/Library.png)
-![Game](./gaseous-server/wwwroot/screenshots/Game.png)
+![Game](./screenshots/Game.png)
-![Emulator](./gaseous-server/wwwroot/screenshots/Emulator.png)
+![Emulator](./screenshots/Emulator.png)
 
 ## Requirements
-* MariaDB 11.1.2+ (preferred) or MySQL Server 8+
+* MySQL Server 8+*
-  * These are the database versions Gaseous has been tested and developed against. Your mileage may vary with earlier versions.
-  * MariaDB is the preferred database server, while MySQL will continue to be supported for existing users (they should be interchangable).
-  * Note that due to the earlier database schema using MySQL specific features, moving to MariaDB from MySQL will require rebuilding your database from scratch. The "Library Scan" background task can be used to re-import all titles.
 * Internet Game Database API Key. See: https://api-docs.igdb.com/#account-creation
 
-# Installation
+***Note**: MariaDB is currently not supported as Gaseous uses features present only in MySQL. This is being tracked in https://github.com/gaseous-project/gaseous-server/issues/93
-See https://github.com/gaseous-project/gaseous-server/wiki/Installation for installation instructions.
-
-# Adding Content
-1. Import signatures: see https://github.com/gaseous-project/gaseous-server/wiki/Signatures
-2. Add ROMs: see https://github.com/gaseous-project/gaseous-server/wiki/Adding-ROMs
-
-## Friends of Gaseous
-* [EmulatorJS](https://github.com/EmulatorJS/EmulatorJS): A fantastic (and fast) Javascript based implementation of RetroArch, supporting a wide variety of platforms. Discord: https://discord.gg/6akryGkETU
-* [RomM](https://github.com/zurdi15/romm): Another self hosted ROM manager. Discord: https://discord.gg/P5HtHnhUDH
 
 ## Third Party Projects
 The following projects are used by Gaseous
-* [ASP.NET](https://dotnet.microsoft.com/en-us/apps/aspnet)
+* https://dotnet.microsoft.com/en-us/apps/aspnet
-* [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json)
+* https://github.com/JamesNK/Newtonsoft.Json
-* [MySQLConnector](https://mysqlconnector.net)
+* https://www.nuget.org/packages/MySql.Data/8.0.32.1
-* [IGDB-DOTNET](https://github.com/kamranayub/igdb-dotnet)
+* https://github.com/kamranayub/igdb-dotnet
-* [EmulatorJS](https://github.com/EmulatorJS/EmulatorJS)
+* https://github.com/EmulatorJS/EmulatorJS
 
 ## Discord Server
-Join our Discord server: https://discord.gg/Nhu7wpT3k4
+[![Join our Discord server!](https://invite.casperiv.dev/?inviteCode=Nhu7wpT3k4&format=svg)](https://discord.gg/Nhu7wpT3k4)
+
+# Setup
+
+## Configuration File
+When Gaseous-Server is started for the first time, it creates a configuration file at ~/.gaseous-server/config.json if it doesn't exist. Some values can be filled in using environment variables (such as in the case of using docker).
+
+### DatabaseConfiguration
+| Attribute | Environment Variable |
+| --------- | -------------------- |
+| HostName  | dbhost               |
+| UserName  | dbuser               |
+| Password  | dbpass               |
+
+### IGDBConfiguration
+| Attribute | Environment Variable |
+| --------- | -------------------- |
+| ClientId  | igdbclientid         |
+| Secret.   | igdbclientsecret     |
+
+### config.json
+```json
+{
+  "DatabaseConfiguration": {
+    "HostName": "localhost",
+    "UserName": "gaseous",
+    "Password": "gaseous",
+    "DatabaseName": "gaseous",
+    "Port": 3306
+  },
+  "IGDBConfiguration": {
+    "ClientId": "<clientid>",
+    "Secret": "<secret>"
+  },
+  "LoggingConfiguration": {
+    "DebugLogging": false,
+    "LogFormat": "text"
+  }
+}
+
+```
+
+## Docker
+### Deploy with the prebuilt Docker image
+Dockerfile and docker-compose.yml files have been provided to make deployment of the server as easy as possible.
+1. Download the docker-compose.yml file
+2. Open the docker-compose.yml file and edit the igdbclientid and igdbclientsecret to the values retrieved from your IGDB account
+3. Run the command ```docker-compose up -d```
+4. Connect to the host on port 5198
+
+### Build and deploy a Docker image from source
+Dockerfile and docker-compose-build.yml files have been provided to make deployment of the server as easy as possible.
+1. Clone the repo with ```git clone https://github.com/gaseous-project/gaseous-server.git```
+2. Change into the gaseous-server directory
+3. Clone the submodules with the command ```git submodule update --init```
+4. Open the docker-compose-build.yml file and edit the igdbclientid and igdbclientsecret to the values retrieved from your IGDB account
+5. Run the command ```docker-compose --file docker-compose-build.yml up -d```
+6. Connect to the host on port 5198
+
+## Source
+### Build and deploy
+1. Install and configure a MySQL instance
+2. Install the dotnet 7.0 packages appropriate for your operating system
+    * See: https://learn.microsoft.com/en-us/dotnet/core/install/linux
+3. Create a database user with permission to create a databse. Gaseous will create the new database and apply the database schema on it's first startup.
+4. Clone the repo with ```git clone https://github.com/gaseous-project/gaseous-server.git```
+5. Change into the gaseous-server directory
+6. As the main branch is the development branch, you might want to change to a stable version - these are tagged with a version number. For example to change to the 1.5.0 release, use the command ```git checkout v1.5.0```
+    * Check the releases page for the version you would like to run: https://github.com/gaseous-project/gaseous-server/releases
+7. Clone the submodules with the command ```git submodule update --init --recursive```
+    * This command will clone the code that the server uses from other projects (currently only EmulatorJS)
+8. Create a directory in the home directory of the user that will run the server. For example, if running as the user ```gaseous```, create the directory ```/home/gaseous/.gaseous-server```
+9. Change into the ```.gaseous-server``` directory created in the previous step
+10. Copy the JSON from the config file above into a new file named ```config.json```
+11. Update the database section with the database server hostname, username, password, and port
+12. Compile the server by changing back to the repo cloned earlier and executing:
+    * ```dotnet restore "gaseous-server/gaseous-server.csproj"```
+    * ```dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained false -c Release -o <output directory>```
+    * replace ```<output directory>``` with the directory of your choosing. The compiled application will be copied there. For this example we'll use ```/opt/gaseous-server```
+13. The server can then be started by executing ```dotnet /opt/gaseous-server/gaseous-server.dll```
+    * If you would like the server to run on a different ip address and port (for example 0.0.0.0:8080), add the --urls argument: ```dotnet /opt/gaseous-server/gaseous-server.dll --urls http://0.0.0.0:8080```
+
+**Note**: The above instructions were tested on macOS Ventura, and Ubuntu 22.04.3. There was a report that Debian 11 had an issue with the git submodule commands (see: https://github.com/gaseous-project/gaseous-server/issues/71). This was possibly due to an older git package.
+
+If the git submodule commands aren't working, you can:
+1. change to the ```gaseous-server/wwwroot/emulators``` directory
+2. delete the ```EmulatorJS``` directory
+3. clone the EmulatorJS repository with ```git clone https://github.com/EmulatorJS/EmulatorJS.git```
+
+### Updating from source
+1. Stop the server
+2. Switch to the source directory
+3. Update your repo:
+    * If running from the main branch, run ```git pull``` to update the repo
+    * If running from another branch or tag, run:
+      * ```git fetch```
+      * ```git checkout <branch or tag name>```
+4. Update the submodules with ```git submodule update --recursive```
+5. Run steps 12 and 13 from the above Build guide
+
+# Adding Content
+While games can be added to the server without them, it is recommended adding some signature DAT files beforehand to allow for better matching of ROMs to games.
+
+These signature DAT files contain a list of titles with hashes for many of the ROM images that have been found by the community.
+
+Currently supported DAT's:
+* TOSEC: https://www.tosecdev.org/downloads/category/56-2023-01-23
+* MAME Arcade and MAME Mess: https://www.progettosnaps.net/dats/MAME
+
+If there are other DAT's you'd like to see support for, please raise an issue with a link to the DAT's.
+
+## Adding signature DAT files
+### TOSEC
+1. Download the DAT files from the source website. For example; from https://www.tosecdev.org/downloads/category/56-2023-01-23
+2. Extract the archive
+3. Copy the DAT files to ~/.gaseous-server/Data/Signatures/TOSEC/
+
+### MAME Arcade
+1. Download the DAT files from the source website. For example; from https://www.progettosnaps.net/dats/MAME
+2. Extract the archive
+3. Copy the file name "MAME 0.257 (arcade).dat" files to ~/.gaseous-server/Data/Signatures/MAME Arcade/
+
+### MAME MESS
+1. Download the DAT files from the source website. For example; from https://www.progettosnaps.net/dats/MAME
+2. Extract the archive
+3. Copy the file name "MAME 0.257 (mess).dat" files to ~/.gaseous-server/Data/Signatures/MAME MESS/
+
+# Adding Game Images
+1. Files can be presented as either stand alone files, or as zip files - currently 7z is unsupported.
+2. Name the file appropriately.
+   * Attempting a search for the game name on https://www.igdb.com can help with file naming. If a hash search is unsuccessful, Gaseous will fall back to attempting to search by the file name.
+3. Add the file to the server:
+   * Click the Upload button in the top right of the main Gaseous web page, and drag the files into the modal. The files will be uploaded and analyzed.
+   * Copy the file to ~/.gaseous-server/Data/Import
+
+# Game Image Title Matching
+Image to game matching follows the following order of operations, stopping the process at the first match:
+### Get the file signature
+1. Attempt a hash search
+2. Attempt to search the signature database for a rom matching the file name - sometimes the hash can not be matched as a highscore table for example was saved to the image
+3. Attempt to parse the file name - clues such as the extension being used to define which platform the file belongs to are used to create a search criteria
+
+**Note**: If the file being scanned is a zip, the file will be extracted and searched. The first file whose signature can be found will be used to match the entire zip archive - be sure that the zip only contains files related to one game.
+
+### Create a list of search candidates
+Before beginning, remove any version numbers, and anything in the search string that is between ()
+1. Add the full name of the image
+2. Add the name of the image with any " - " replaced by ": "
+3. Add the name of the image with text after a " - " removed
+4. Add the name of the image with text after a ": " removed
+
+### Search IGDB for a game match
+Loop through each of the search candidates searching using:
+1. "where" - exact match as the search candidate
+2. "wherefuzzy" - partial match using wildcards
+3. "search" - uses a more flexible search method
+4. "searchNoPlatform" - uses the "search" method, but does not constrain the search to the determined platform
+
+**Note**: If more than one result is found, the seach will loop through the returned results:
+* If an exact (case-insensitive) match is found, that result is used for the match
+* If still no match, the image will be set as "Unknown" as there is no way for Gaseous to know which title is the correct one.

build/Dockerfile

@@ -1,73 +0,0 @@
-FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
-ARG TARGETARCH
-ARG BUILDPLATFORM
-WORKDIR /App
-EXPOSE 80
-
-RUN echo "Target: $TARGETARCH"
-RUN echo "Build: $BUILDPLATFORM"
-
-# Copy everything
-COPY .. ./
-
-# Build Gaseous Web Server
-# Restore as distinct layers
-RUN dotnet restore "gaseous-server/gaseous-server.csproj" -a $TARGETARCH
-# Build and publish a release
-RUN dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
-
-# Build Gaseous CLI
-# Restore as distinct layers
-RUN dotnet restore "gaseous-cli/gaseous-cli.csproj" -a $TARGETARCH
-# Build and publish a release
-RUN dotnet publish "gaseous-cli/gaseous-cli.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
-
-# update apt-get
-RUN apt-get update
-
-# # download and unzip EmulatorJS from CDN
-RUN apt-get install -y p7zip-full
-RUN mkdir -p out/wwwroot/emulators/EmulatorJS
-RUN wget https://cdn.emulatorjs.org/releases/4.0.12.7z
-RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.0.12.7z
-
-# clean up apt-get
-RUN apt-get clean && rm -rf /var/lib/apt/lists
-
-# Build runtime image
-FROM mcr.microsoft.com/dotnet/aspnet:8.0
-ENV INDOCKER=1
-WORKDIR /App
-COPY --from=build-env /App/out .
-
-# variables
-ARG PUID=1000
-ARG PGID=1000
-ARG dbhost=localhost
-ARG dbuser=root
-ARG dbpass=gaseous
-
-ENV PUID=${PUID}
-ENV PGID=${PGID}
-ENV dbhost=${dbhost}
-ENV dbuser=${dbuser}
-ENV dbpass=${dbpass}
-
-# install supervisord
-RUN apt-get update && apt-get install -y supervisor
-COPY ../build/standard/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
-RUN mkdir -p /var/run/supervisord
-RUN mkdir -p /var/log/supervisord
-
-# clean up apt-get
-RUN apt-get clean && rm -rf /var/lib/apt/lists
-
-# copy entrypoint
-COPY ../build/standard/entrypoint.sh /usr/sbin/entrypoint.sh
-RUN chmod +x /usr/sbin/entrypoint.sh
-
-# volumes
-VOLUME /home/gaseous/.gaseous-server
-
-# start services
-ENTRYPOINT [ "/usr/sbin/entrypoint.sh" ]

build/Dockerfile-EmbeddedDB

@@ -1,79 +0,0 @@
-FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
-ARG TARGETARCH
-ARG BUILDPLATFORM
-WORKDIR /App
-EXPOSE 80
-
-RUN echo "Target: $TARGETARCH"
-RUN echo "Build: $BUILDPLATFORM"
-
-# Copy everything
-COPY .. ./
-
-# Build Gaseous Web Server
-# Restore as distinct layers
-RUN dotnet restore "gaseous-server/gaseous-server.csproj" -a $TARGETARCH
-# Build and publish a release
-RUN dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
-
-# Build Gaseous CLI
-# Restore as distinct layers
-RUN dotnet restore "gaseous-cli/gaseous-cli.csproj" -a $TARGETARCH
-# Build and publish a release
-RUN dotnet publish "gaseous-cli/gaseous-cli.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
-
-# update apt-get
-RUN apt-get update
-
-# # download and unzip EmulatorJS from CDN
-RUN apt-get install -y p7zip-full
-RUN mkdir -p out/wwwroot/emulators/EmulatorJS
-RUN wget https://cdn.emulatorjs.org/releases/4.0.12.7z
-RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.0.12.7z
-
-# Build runtime image
-FROM mcr.microsoft.com/dotnet/aspnet:8.0
-ENV INDOCKER=1
-WORKDIR /App
-COPY --from=build-env /App/out .
-
-# variables
-ARG PUID=1000
-ARG PGID=1000
-ARG dbhost=localhost
-ARG dbuser=root
-ARG dbpass=gaseous
-ARG MARIADB_ROOT_PASSWORD=$dbpass
-
-ENV PUID=${PUID}
-ENV PGID=${PGID}
-ENV dbhost=${dbhost}
-ENV dbuser=${dbuser}
-ENV dbpass=${dbpass}
-ENV MARIADB_ROOT_PASSWORD=${dbpass}
-
-# install mariadb
-RUN DEBIAN_FRONTEND=noninteractive && \
-    apt-get update && apt-get install -y mariadb-server
-RUN mkdir -p /run/mysqld
-COPY ../build/embeddeddb/mariadb.sh /usr/sbin/start-mariadb.sh
-RUN chmod +x /usr/sbin/start-mariadb.sh
-
-# install supervisord
-RUN apt-get install -y supervisor
-COPY ../build/embeddeddb/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
-RUN mkdir -p /var/run/supervisord
-RUN mkdir -p /var/log/supervisord
-
-# clean up apt-get
-RUN apt-get clean && rm -rf /var/lib/apt/lists
-
-# copy entrypoint
-COPY ../build/embeddeddb/entrypoint.sh /usr/sbin/entrypoint.sh
-RUN chmod +x /usr/sbin/entrypoint.sh
-
-# volumes
-VOLUME /home/gaseous/.gaseous-server /var/lib/mysql
-
-# start services
-ENTRYPOINT [ "/usr/sbin/entrypoint.sh" ]

build/embeddeddb/entrypoint.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-
-# create the user
-echo "Creating user gaseous with UID ${PUID} and GID ${PGID}"
-groupadd -g ${PGID} gaseous
-useradd -u ${PUID} -g ${PGID} -m gaseous -d /home/gaseous -G sudo 
-usermod -p "*" gaseous
-mkdir -p /home/gaseous/.aspnet
-chown -R ${PUID} /App /home/gaseous/.aspnet
-chgrp -R ${PGID} /App /home/gaseous/.aspnet
-mkdir -p /home/gaseous/.gaseous-server
-chown -R ${PUID} /App /home/gaseous/.gaseous-server
-chgrp -R ${PGID} /App /home/gaseous/.gaseous-server
-
-# Set MariaDB permissions
-mkdir -p /var/lib/mysql /var/log/mariadb /run/mysqld
-chown -R ${PUID} /var/lib/mysql /var/log/mariadb /run/mysqld
-chgrp -R ${PGID} /var/lib/mysql /var/log/mariadb /run/mysqld
-
-# Start supervisord and services
-/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf

build/embeddeddb/mariadb.sh

@@ -1,25 +0,0 @@
-#!/bin/sh
-
-# install the database
-echo "Installing MariaDB"
-/usr/bin/mariadb-install-db --datadir=/var/lib/mysql --user=gaseous
-
-# start the database server without network or grant tables
-echo "Starting MariaDB"
-/usr/sbin/mariadbd --datadir=/var/lib/mysql  --skip-grant-tables --skip-networking &
-
-# wait for the server to start
-sleep 5
-
-# change the root password
-echo "Setting MariaDB root password"
-mariadb -u root -e "FLUSH PRIVILEGES; ALTER USER 'root'@'localhost' IDENTIFIED BY '$MARIADB_ROOT_PASSWORD'; ALTER USER 'gaseous'@'localhost' IDENTIFIED BY '$MARIADB_ROOT_PASSWORD'; FLUSH PRIVILEGES; SHUTDOWN;"
-
-# stop the server
-sleep 5
-echo "Stopping MariaDB"
-killall mariadbd
-
-# start the server normally
-echo "Starting MariaDB"
-/usr/sbin/mariadbd --datadir=/var/lib/mysql --user=gaseous

build/embeddeddb/supervisord.conf

@@ -1,37 +0,0 @@
-[supervisord]
-user=root
-nodaemon=true
-logfile=/var/log/supervisord/supervisord.log
-logfile_maxbytes=50
-logfile_backups=5
-pidfile=/var/run/supervisord/supervisord.pid
-loglevel = info
-
-[unix_http_server]
-file=/var/run/supervisord/supervisor.sock
-chmod=0700
-
-[rpcinterface:supervisor]
-supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
-
-[supervisorctl]
-serverurl=unix:///var/run/supervisord/supervisor.sock
-
-[program:mariadb]
-user=gaseous
-command=bash -c "/usr/sbin/start-mariadb.sh"
-autostart=true
-autorestart=true
-redirect_stderr=true
-stdout_logfile=/dev/fd/1
-stdout_logfile_maxbytes=0
-
-[program:gaseous-server]
-user=gaseous
-command=dotnet /App/gaseous-server.dll
-environment=HOME="/home/gaseous",USER="gaseous"
-autostart=true
-autorestart=true
-redirect_stderr=true
-stdout_logfile=/dev/fd/1
-stdout_logfile_maxbytes=0

build/standard/entrypoint.sh

@@ -1,16 +0,0 @@
-#!/bin/sh
-
-# create the user
-echo "Creating user gaseous with UID ${PUID} and GID ${PGID}"
-groupadd -g ${PGID} gaseous
-useradd -u ${PUID} -g ${PGID} -m gaseous -d /home/gaseous -G sudo 
-usermod -p "*" gaseous
-mkdir -p /home/gaseous/.aspnet
-chown -R ${PUID} /App /home/gaseous/.aspnet
-chgrp -R ${PGID} /App /home/gaseous/.aspnet
-mkdir -p /home/gaseous/.gaseous-server
-chown -R ${PUID} /App /home/gaseous/.gaseous-server
-chgrp -R ${PGID} /App /home/gaseous/.gaseous-server
-
-# Start supervisord and services
-/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf

build/standard/supervisord.conf

@@ -1,28 +0,0 @@
-[supervisord]
-user=root
-nodaemon=true
-logfile=/var/log/supervisord/supervisord.log
-logfile_maxbytes=50
-logfile_backups=5
-pidfile=/var/run/supervisord/supervisord.pid
-loglevel = info
-
-[unix_http_server]
-file=/var/run/supervisord/supervisor.sock
-chmod=0700
-
-[rpcinterface:supervisor]
-supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
-
-[supervisorctl]
-serverurl=unix:///var/run/supervisord/supervisor.sock
-
-[program:gaseous-server]
-user=gaseous
-command=dotnet /App/gaseous-server.dll
-environment=HOME="/home/gaseous",USER="gaseous"
-autostart=true
-autorestart=true
-redirect_stderr=true
-stdout_logfile=/dev/fd/1
-stdout_logfile_maxbytes=0

docker-compose-build.yml

@@ -4,7 +4,6 @@ services:
     container_name: gaseous-server
     build:
       context: ./
-      dockerfile: ./build/Dockerfile
     restart: unless-stopped
     networks:
       - gaseous
@@ -13,9 +12,8 @@ services:
     ports:
       - 5198:80
     volumes:
-      - gs:/home/gaseous/.gaseous-server
+      - gs:/root/.gaseous-server
     environment:
-      - TZ=Australia/Sydney
       - dbhost=gsdb
       - dbuser=root
       - dbpass=gaseous
@@ -23,16 +21,16 @@ services:
       - igdbclientsecret=<clientsecret>
   gsdb:
     container_name: gsdb
-    image: mariadb
+    image: mysql:8
     restart: unless-stopped
     networks:
       - gaseous
     volumes:
       - gsdb:/var/lib/mysql
     environment:
-      - MARIADB_ROOT_PASSWORD=gaseous
+      - MYSQL_ROOT_PASSWORD=gaseous
-      - MARIADB_USER=gaseous
+      - MYSQL_USER=gaseous
-      - MARIADB_PASSWORD=gaseous
+      - MYSQL_PASSWORD=gaseous
 networks:
   gaseous:
     driver: bridge

docker-compose.yml

@@ -0,0 +1,38 @@
+version: '2'
+services:
+  gaseous-server:
+    container_name: gaseous-server
+    image: gaseousgames/gaseousserver:latest
+    restart: unless-stopped
+    networks:
+      - gaseous
+    depends_on:
+      - gsdb
+    ports:
+      - 5198:80
+    volumes:
+      - gs:/root/.gaseous-server
+    environment:
+      - dbhost=gsdb
+      - dbuser=root
+      - dbpass=gaseous
+      - igdbclientid=<clientid>
+      - igdbclientsecret=<clientsecret>
+  gsdb:
+    container_name: gsdb
+    image: mysql:8
+    restart: unless-stopped
+    networks:
+      - gaseous
+    volumes:
+      - gsdb:/var/lib/mysql
+    environment:
+      - MYSQL_ROOT_PASSWORD=gaseous
+      - MYSQL_USER=gaseous
+      - MYSQL_PASSWORD=gaseous
+networks:
+  gaseous:
+    driver: bridge
+volumes:
+  gs:
+  gsdb:

gaseous-cli/Program.cs

@@ -1,354 +0,0 @@
-using System;
-using Authentication;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-/* ------------------------------------------------- */
-/* This tool is a CLI tool that is used to manage    */
-/* the Gaseous Server.                               */
-/* Functions such as user management, and backups    */
-/* are available.                                    */
-/* ------------------------------------------------- */
-
-// load app settings
-Config.InitSettings();
-
-// set up database connection
-Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-// set up identity
-IServiceCollection services = new ServiceCollection();
-services.AddLogging();
-
-services.AddIdentity<ApplicationUser, ApplicationRole>(options =>
-        {
-            options.Password.RequireDigit = true;
-            options.Password.RequireLowercase = true;
-            options.Password.RequireNonAlphanumeric = false;
-            options.Password.RequireUppercase = true;
-            options.Password.RequiredLength = 10;
-            options.User.AllowedUserNameCharacters = null;
-            options.User.RequireUniqueEmail = true;
-            options.SignIn.RequireConfirmedPhoneNumber = false;
-            options.SignIn.RequireConfirmedEmail = false;
-            options.SignIn.RequireConfirmedAccount = false;
-        })
-    .AddUserStore<UserStore>()
-    .AddRoleStore<RoleStore>()
-    ;
-services.AddScoped<UserStore>();
-services.AddScoped<RoleStore>();
-
-services.AddTransient<IUserStore<ApplicationUser>, UserStore>();
-services.AddTransient<IRoleStore<ApplicationRole>, RoleStore>();
-var userManager = services.BuildServiceProvider().GetService<UserManager<ApplicationUser>>();
-
-// load the command line arguments
-string[] cmdArgs = Environment.GetCommandLineArgs();
-
-// check if the user has entered any arguments
-if (cmdArgs.Length == 1)
-{
-    // no arguments were entered
-    Console.WriteLine("Gaseous CLI - A tool for managing the Gaseous Server");
-    Console.WriteLine("Usage: gaseous-cli [command] [options]");
-    Console.WriteLine("Commands:");
-    Console.WriteLine("  user [command] [options] - Manage users");
-    Console.WriteLine("  role [command] [options] - Manage roles");
-    // Console.WriteLine("  backup [command] [options] - Manage backups");
-    // Console.WriteLine("  restore [command] [options] - Restore backups");
-    Console.WriteLine("  help - Display this help message");
-    return;
-}
-
-// check if the user has entered the help command
-if (cmdArgs[1] == "help")
-{
-    // display the help message
-    Console.WriteLine("Gaseous CLI - A tool for managing the Gaseous Server");
-    Console.WriteLine("Usage: gaseous-cli [command] [options]");
-    Console.WriteLine("Commands:");
-    Console.WriteLine("  user [command] [options] - Manage users");
-    Console.WriteLine("  role [command] [options] - Manage roles");
-    // Console.WriteLine("  backup [command] [options] - Manage backups");
-    // Console.WriteLine("  restore [command] [options] - Restore backups");
-    Console.WriteLine("  help - Display this help message");
-    return;
-}
-
-// check if the user has entered the user command
-if (cmdArgs[1] == "user")
-{
-    // check if the user has entered any arguments
-    if (cmdArgs.Length == 2)
-    {
-        // no arguments were entered
-        Console.WriteLine("User Management");
-        Console.WriteLine("Usage: gaseous-cli user [command] [options]");
-        Console.WriteLine("Commands:");
-        Console.WriteLine("  add [username] [password] - Add a new user");
-        Console.WriteLine("  delete [username] - Delete a user");
-        Console.WriteLine("  resetpassword [username] [password] - Reset a user's password");
-        Console.WriteLine("  list - List all users");
-        return;
-    }
-
-    // check if the user has entered the add command
-    if (cmdArgs[2] == "add")
-    {
-        // check if the user has entered the username and password
-        if (cmdArgs.Length < 5)
-        {
-            // the username and password were not entered
-            Console.WriteLine("Error: Please enter a username and password");
-            return;
-        }
-
-        // add a new user
-        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
-        if (userTable.GetUserByEmail(cmdArgs[3]) != null)
-        {
-            Console.WriteLine("Error: User already exists");
-            return;
-        }
-
-        // create the user object
-        ApplicationUser user = new ApplicationUser
-        {
-            Id = Guid.NewGuid().ToString(),
-            Email = cmdArgs[3],
-            NormalizedEmail = cmdArgs[3].ToUpper(),
-            EmailConfirmed = true,
-            UserName = cmdArgs[3],
-            NormalizedUserName = cmdArgs[3].ToUpper()
-        };
-
-        // create the password
-        PasswordHasher<ApplicationUser> passwordHasher = new PasswordHasher<ApplicationUser>();
-        user.PasswordHash = passwordHasher.HashPassword(user, cmdArgs[4]);
-
-        await userManager.CreateAsync(user);
-        await userManager.AddToRoleAsync(user, "Player");
-
-        Console.WriteLine("User created successfully with default role: Player");
-
-        return;
-    }
-
-    // check if the user has entered the delete command
-    if (cmdArgs[2] == "delete")
-    {
-        // check if the user has entered the username
-        if (cmdArgs.Length < 4)
-        {
-            // the username was not entered
-            Console.WriteLine("Error: Please enter a username");
-            return;
-        }
-
-        // delete the user
-        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
-        ApplicationUser user = userTable.GetUserByEmail(cmdArgs[3]);
-        if (user == null)
-        {
-            Console.WriteLine("Error: User not found");
-            return;
-        }
-
-        await userManager.DeleteAsync(user);
-
-        Console.WriteLine("User deleted successfully");
-
-        return;
-    }
-
-    // check if the user has entered the resetpassword command
-    if (cmdArgs[2] == "resetpassword")
-    {
-        // check if the user has entered the username and password
-        if (cmdArgs.Length < 5)
-        {
-            // the username and password were not entered
-            Console.WriteLine("Error: Please enter a username and password");
-            return;
-        }
-
-        // reset the user's password
-        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
-        ApplicationUser user = userTable.GetUserByEmail(cmdArgs[3]);
-        if (user == null)
-        {
-            Console.WriteLine("Error: User not found");
-            return;
-        }
-
-        // create the password
-        PasswordHasher<ApplicationUser> passwordHasher = new PasswordHasher<ApplicationUser>();
-        user.PasswordHash = passwordHasher.HashPassword(user, cmdArgs[4]);
-
-        await userManager.UpdateAsync(user);
-
-        Console.WriteLine("Password reset successfully");
-
-        return;
-    }
-
-    // check if the user has entered the list command
-    if (cmdArgs[2] == "list")
-    {
-        // list all users
-        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
-        var userList = userTable.GetUsers();
-        foreach (var user in userList)
-        {
-            var roles = await userManager.GetRolesAsync(user);
-            Console.WriteLine(user.Email + " - " + string.Join(", ", roles));
-        }
-        return;
-    }
-}
-
-// check if the user has entered the role command
-if (cmdArgs[1] == "role")
-{
-    // check if the user has entered any arguments
-    if (cmdArgs.Length == 2)
-    {
-        // no arguments were entered
-        Console.WriteLine("Role Management");
-        Console.WriteLine("Usage: gaseous-cli role [command] [options]");
-        Console.WriteLine("Commands:");
-        Console.WriteLine("  set [username] [role] - Set the role of a user");
-        Console.WriteLine("  list - List all roles");
-        return;
-    }
-
-    // check if the user has entered the role command
-    if (cmdArgs[2] == "set")
-    {
-        // check if the user has entered the username and role
-        if (cmdArgs.Length < 5)
-        {
-            // the username and role were not entered
-            Console.WriteLine("Error: Please enter a username and role");
-            return;
-        }
-
-        // set the role of the user
-        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
-        ApplicationUser user = userTable.GetUserByEmail(cmdArgs[3]);
-        if (user == null)
-        {
-            Console.WriteLine("Error: User not found");
-            return;
-        }
-
-        // remove all existing roles from user
-        var roles = await userManager.GetRolesAsync(user);
-        await userManager.RemoveFromRolesAsync(user, roles.ToArray());
-
-        // add the new role to the user
-        await userManager.AddToRoleAsync(user, cmdArgs[4]);
-
-        Console.WriteLine("Role set successfully");
-
-        return;
-    }
-
-    // check if the user has entered the list command
-    if (cmdArgs[2] == "list")
-    {
-        // list all roles
-        string[] roles = { "Player", "Gamer", "Admin" };
-        foreach (var role in roles)
-        {
-            Console.WriteLine(role);
-        }
-        return;
-    }
-}
-
-// // check if the user has entered the backup command
-// if (cmdArgs[1] == "backup")
-// {
-//     // check if the user has entered any arguments
-//     if (cmdArgs.Length == 2)
-//     {
-//         // no arguments were entered
-//         Console.WriteLine("Backup Management");
-//         Console.WriteLine("Usage: gaseous-cli backup [command] [options]");
-//         Console.WriteLine("Commands:");
-//         Console.WriteLine("  create - Create a backup");
-//         Console.WriteLine("  list - List all backups");
-//         Console.WriteLine("  remove [backup_id] - Remove a backup");
-//         return;
-//     }
-
-//     // check if the user has entered the create command
-//     if (cmdArgs[2] == "create")
-//     {
-//         // create a backup
-//         Backup.CreateBackup();
-//         return;
-//     }
-
-//     // check if the user has entered the list command
-//     if (cmdArgs[2] == "list")
-//     {
-//         // list all backups
-//         Backup.ListBackups();
-//         return;
-//     }
-
-//     // check if the user has entered the remove command
-//     if (cmdArgs[2] == "remove")
-//     {
-//         // check if the user has entered the backup id
-//         if (cmdArgs.Length < 4)
-//         {
-//             // the backup id was not entered
-//             Console.WriteLine("Error: Please enter a backup id");
-//             return;
-//         }
-
-//         // remove the backup
-//         Backup.RemoveBackup(cmdArgs[3]);
-//         return;
-//     }
-// }
-
-// // check if the user has entered the restore command
-// if (cmdArgs[1] == "restore")
-// {
-//     // check if the user has entered any arguments
-//     if (cmdArgs.Length == 2)
-//     {
-//         // no arguments were entered
-//         Console.WriteLine("Restore Management");
-//         Console.WriteLine("Usage: gaseous-cli restore [command] [options]");
-//         Console.WriteLine("Commands:");
-//         Console.WriteLine("  restore [backup_id] - Restore a backup");
-//         return;
-//     }
-
-//     // check if the user has entered the restore command
-//     if (cmdArgs[2] == "restore")
-//     {
-//         // check if the user has entered the backup id
-//         if (cmdArgs.Length < 4)
-//         {
-//             // the backup id was not entered
-//             Console.WriteLine("Error: Please enter a backup id");
-//             return;
-//         }
-
-//         // restore the backup
-//         Restore.RestoreBackup(cmdArgs[3]);
-//         return;
-//     }
-// }
-
-// the user entered an invalid command
-Console.WriteLine("Error: Invalid command");

gaseous-cli/gaseous-cli.csproj

@@ -1,28 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
-    <RootNamespace>gaseous_cli</RootNamespace>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <WarningLevel>4</WarningLevel>
-    <DocumentationFile>bin\Debug\net8.0\gaseous-cli.xml</DocumentationFile>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <WarningLevel>4</WarningLevel>
-    <DocumentationFile>bin\Release\net8.0\gaseous-cli.xml</DocumentationFile>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-    <PackageReference Include="MySqlConnector" Version="2.3.7" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\gaseous-server\gaseous-server.csproj" />
-  </ItemGroup>
-</Project>

gaseous-server/Classes/Auth/Classes/IdentityRole.cs

@@ -1,16 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that implements the ASP.NET Identity
-    /// IRole interface 
-    /// </summary>
-    public class ApplicationRole : IdentityRole
-    {
-    }
-}

gaseous-server/Classes/Auth/Classes/IdentityUser.cs

@@ -1,17 +0,0 @@
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-using System;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that implements the ASP.NET Identity
-    /// IUser interface 
-    /// </summary>
-    public class ApplicationUser : IdentityUser
-    {
-        public SecurityProfileViewModel SecurityProfile { get; set; }
-        public List<UserPreferenceViewModel> UserPreferences { get; set; }
-        public Guid ProfileId { get; set; }
-    }
-}

gaseous-server/Classes/Auth/Classes/RoleStore.cs

@@ -1,171 +0,0 @@
-using System;
-using System.Security.Claims;
-using System.Threading.Tasks;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-using MySqlConnector;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that implements the key ASP.NET Identity role store iterfaces
-    /// </summary>
-    public class RoleStore : IQueryableRoleStore<ApplicationRole>
-    {
-        private RoleTable roleTable;
-        public Database Database { get; private set; }
-
-        public IQueryable<ApplicationRole> Roles
-        {
-            get
-            {
-                List<ApplicationRole> roles = roleTable.GetRoles();
-                return roles.AsQueryable();
-            }
-        }
-
-        public RoleStore()
-        {
-            Database = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            roleTable = new RoleTable(Database);
-        }
-
-        /// <summary>
-        /// Constructor that takes a MySQLDatabase as argument 
-        /// </summary>
-        /// <param name="database"></param>
-        public RoleStore(Database database)
-        {
-            Database = database;
-            roleTable = new RoleTable(database);
-        }
-
-        public Task<IdentityResult> CreateAsync(ApplicationRole role, CancellationToken cancellationToken)
-        {
-            if (role == null)
-            {
-                throw new ArgumentNullException("role");
-            }
-
-            roleTable.Insert(role);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public Task<IdentityResult> DeleteAsync(ApplicationRole role, CancellationToken cancellationToken)
-        {
-            if (role == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            roleTable.Delete(role.Id);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public Task<ApplicationRole> FindByIdAsync(string roleId, CancellationToken cancellationToken)
-        {
-            ApplicationRole result = roleTable.GetRoleById(roleId) as ApplicationRole;
-
-            return Task.FromResult<ApplicationRole>(result);
-        }
-
-        public Task<bool> RoleExistsAsync(string roleId, CancellationToken cancellationToken)
-        {
-            ApplicationRole? result = roleTable.GetRoleById(roleId) as ApplicationRole;
-
-            if (result == null)
-            {
-                return Task.FromResult<bool>(false);
-            }
-            else
-            {
-                return Task.FromResult<bool>(true);
-            }
-        }
-
-        public Task<ApplicationRole?> FindByNameAsync(string roleName, CancellationToken cancellationToken)
-        {
-            ApplicationRole? result = roleTable.GetRoleByName(roleName) as ApplicationRole;
-
-            return Task.FromResult<ApplicationRole?>(result);
-        }
-
-        public Task<IdentityResult> UpdateAsync(ApplicationRole role, CancellationToken cancellationToken)
-        {
-            if (role == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            roleTable.Update(role);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public void Dispose()
-        {
-            if (Database != null)
-            {
-                Database = null;
-            }
-        }
-
-        public Task<string> GetRoleIdAsync(ApplicationRole role, CancellationToken cancellationToken)
-        {
-            if (role != null)
-            {
-                return Task.FromResult<string>(roleTable.GetRoleId(role.Name));
-            }
-
-            return Task.FromResult<string>(null);
-        }
-
-        public Task<string?> GetRoleNameAsync(ApplicationRole role, CancellationToken cancellationToken)
-        {
-            if (role != null)
-            {
-                return Task.FromResult<string?>(roleTable.GetRoleName(role.Id));
-            }
-
-            return Task.FromResult<string?>(null);
-        }
-
-        public Task SetRoleNameAsync(ApplicationRole role, string? roleName, CancellationToken cancellationToken)
-        {
-            if (role == null)
-            {
-                throw new ArgumentNullException("role");
-            }
-
-            role.Name = roleName;
-            roleTable.Update(role);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public Task<string?> GetNormalizedRoleNameAsync(ApplicationRole role, CancellationToken cancellationToken)
-        {
-            if (role != null)
-            {
-                return Task.FromResult<string?>(roleTable.GetRoleName(role.Id));
-            }
-
-            return Task.FromResult<string?>(null);
-        }
-
-        public Task SetNormalizedRoleNameAsync(ApplicationRole role, string? normalizedName, CancellationToken cancellationToken)
-        {
-            if (role == null)
-            {
-                throw new ArgumentNullException("role");
-            }
-
-            role.Name = normalizedName;
-            roleTable.Update(role);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-    }
-}

gaseous-server/Classes/Auth/Classes/RoleTable.cs

@@ -1,168 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that represents the Role table in the MySQL Database
-    /// </summary>
-    public class RoleTable
-    {
-        private Database _database;
-
-        /// <summary>
-        /// Constructor that takes a MySQLDatabase instance 
-        /// </summary>
-        /// <param name="database"></param>
-        public RoleTable(Database database)
-        {
-            _database = database;
-        }
-
-        /// <summary>
-        /// Deltes a role from the Roles table
-        /// </summary>
-        /// <param name="roleId">The role Id</param>
-        /// <returns></returns>
-        public int Delete(string roleId)
-        {
-            string commandText = "Delete from Roles where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@id", roleId);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Inserts a new Role in the Roles table
-        /// </summary>
-        /// <param name="roleName">The role's name</param>
-        /// <returns></returns>
-        public int Insert(ApplicationRole role)
-        {
-            string commandText = "Insert into Roles (Id, Name) values (@id, @name)";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@name", role.Name);
-            parameters.Add("@id", role.Id);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Returns a role name given the roleId
-        /// </summary>
-        /// <param name="roleId">The role Id</param>
-        /// <returns>Role name</returns>
-        public string? GetRoleName(string roleId)
-        {
-            string commandText = "Select Name from Roles where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@id", roleId);
-
-            DataTable table = _database.ExecuteCMD(commandText, parameters);
-
-            if (table.Rows.Count == 0)
-            {
-                return null;
-            }
-            else
-            {
-                return (string)table.Rows[0][0];
-            }
-        }
-
-        /// <summary>
-        /// Returns the role Id given a role name
-        /// </summary>
-        /// <param name="roleName">Role's name</param>
-        /// <returns>Role's Id</returns>
-        public string? GetRoleId(string roleName)
-        {
-            string? roleId = null;
-            string commandText = "Select Id from Roles where Name = @name";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@name", roleName } };
-
-            DataTable result = _database.ExecuteCMD(commandText, parameters);
-            if (result.Rows.Count > 0)
-            {
-                return Convert.ToString(result.Rows[0][0]);
-            }
-
-            return roleId;
-        }
-
-        /// <summary>
-        /// Gets the ApplicationRole given the role Id
-        /// </summary>
-        /// <param name="roleId"></param>
-        /// <returns></returns>
-        public ApplicationRole? GetRoleById(string roleId)
-        {
-            var roleName = GetRoleName(roleId);
-            ApplicationRole? role = null;
-
-            if (roleName != null)
-            {
-                role = new ApplicationRole();
-                role.Id = roleId;
-                role.Name = roleName;
-                role.NormalizedName = roleName.ToUpper();
-            }
-
-            return role;
-
-        }
-
-        /// <summary>
-        /// Gets the ApplicationRole given the role name
-        /// </summary>
-        /// <param name="roleName"></param>
-        /// <returns></returns>
-        public ApplicationRole? GetRoleByName(string roleName)
-        {
-            var roleId = GetRoleId(roleName);
-            ApplicationRole role = null;
-
-            if (roleId != null)
-            {
-                role = new ApplicationRole();
-                role.Id = roleId;
-                role.Name = roleName;
-                role.NormalizedName = roleName.ToUpper();
-            }
-
-            return role;
-        }
-
-        public int Update(ApplicationRole role)
-        {
-            string commandText = "Update Roles set Name = @name where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@id", role.Id);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        public List<ApplicationRole> GetRoles()
-        {
-            List<ApplicationRole> roles = new List<ApplicationRole>();
-
-            string commandText = "Select Name from Roles";
-
-            var rows = _database.ExecuteCMDDict(commandText);
-            foreach (Dictionary<string, object> row in rows)
-            {
-                ApplicationRole role = (ApplicationRole)Activator.CreateInstance(typeof(ApplicationRole));
-                role.Id = (string)row["Id"];
-                role.Name = (string)row["Name"];
-                role.NormalizedName = ((string)row["Name"]).ToUpper();
-                roles.Add(role);
-            }
-
-            return roles;
-        }
-    }
-}

gaseous-server/Classes/Auth/Classes/UserClaimsTable.cs

@@ -1,95 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Security.Claims;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that represents the UserClaims table in the MySQL Database
-    /// </summary>
-    public class UserClaimsTable
-    {
-        private Database _database;
-
-        /// <summary>
-        /// Constructor that takes a MySQLDatabase instance 
-        /// </summary>
-        /// <param name="database"></param>
-        public UserClaimsTable(Database database)
-        {
-            _database = database;
-        }
-
-        /// <summary>
-        /// Returns a ClaimsIdentity instance given a userId
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public ClaimsIdentity FindByUserId(string userId)
-        {
-            ClaimsIdentity claims = new ClaimsIdentity();
-            string commandText = "Select * from UserClaims where UserId = @userId";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@UserId", userId } };
-
-            var rows = _database.ExecuteCMD(commandText, parameters).Rows;
-            foreach (DataRow row in rows)
-            {
-                Claim claim = new Claim((string)row["ClaimType"], (string)row["ClaimValue"]);
-                claims.AddClaim(claim);
-            }
-
-            return claims;
-        }
-
-        /// <summary>
-        /// Deletes all claims from a user given a userId
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public int Delete(string userId)
-        {
-            string commandText = "Delete from UserClaims where UserId = @userId";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("userId", userId);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Inserts a new claim in UserClaims table
-        /// </summary>
-        /// <param name="userClaim">User's claim to be added</param>
-        /// <param name="userId">User's id</param>
-        /// <returns></returns>
-        public int Insert(Claim userClaim, string userId)
-        {
-            string commandText = "Insert into UserClaims (ClaimValue, ClaimType, UserId) values (@value, @type, @userId)";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("value", userClaim.Value);
-            parameters.Add("type", userClaim.Type);
-            parameters.Add("userId", userId);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Deletes a claim from a user 
-        /// </summary>
-        /// <param name="user">The user to have a claim deleted</param>
-        /// <param name="claim">A claim to be deleted from user</param>
-        /// <returns></returns>
-        public int Delete(IdentityUser user, Claim claim)
-        {
-            string commandText = "Delete from UserClaims where UserId = @userId and @ClaimValue = @value and ClaimType = @type";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("userId", user.Id);
-            parameters.Add("value", claim.Value);
-            parameters.Add("type", claim.Type);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-    }
-}

gaseous-server/Classes/Auth/Classes/UserLoginsTable.cs

@@ -1,117 +0,0 @@
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-using System.Collections.Generic;
-using System.Data;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that represents the UserLogins table in the MySQL Database
-    /// </summary>
-    public class UserLoginsTable
-    {
-        private Database _database;
-
-        /// <summary>
-        /// Constructor that takes a MySQLDatabase instance 
-        /// </summary>
-        /// <param name="database"></param>
-        public UserLoginsTable(Database database)
-        {
-            _database = database;
-        }
-
-        /// <summary>
-        /// Deletes a login from a user in the UserLogins table
-        /// </summary>
-        /// <param name="user">User to have login deleted</param>
-        /// <param name="login">Login to be deleted from user</param>
-        /// <returns></returns>
-        public int Delete(IdentityUser user, UserLoginInfo login)
-        {
-            string commandText = "Delete from UserLogins where UserId = @userId and LoginProvider = @loginProvider and ProviderKey = @providerKey";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("UserId", user.Id);
-            parameters.Add("loginProvider", login.LoginProvider);
-            parameters.Add("providerKey", login.ProviderKey);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Deletes all Logins from a user in the UserLogins table
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public int Delete(string userId)
-        {
-            string commandText = "Delete from UserLogins where UserId = @userId";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("UserId", userId);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Inserts a new login in the UserLogins table
-        /// </summary>
-        /// <param name="user">User to have new login added</param>
-        /// <param name="login">Login to be added</param>
-        /// <returns></returns>
-        public int Insert(IdentityUser user, UserLoginInfo login)
-        {
-            string commandText = "Insert into UserLogins (LoginProvider, ProviderKey, UserId) values (@loginProvider, @providerKey, @userId)";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("loginProvider", login.LoginProvider);
-            parameters.Add("providerKey", login.ProviderKey);
-            parameters.Add("userId", user.Id);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Return a userId given a user's login
-        /// </summary>
-        /// <param name="userLogin">The user's login info</param>
-        /// <returns></returns>
-        public string? FindUserIdByLogin(UserLoginInfo userLogin)
-        {
-            string commandText = "Select UserId from UserLogins where LoginProvider = @loginProvider and ProviderKey = @providerKey";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("loginProvider", userLogin.LoginProvider);
-            parameters.Add("providerKey", userLogin.ProviderKey);
-
-            DataTable table = _database.ExecuteCMD(commandText, parameters);
-
-            if (table.Rows.Count == 0)
-            {
-                return null;
-            }
-            else
-            {
-                return (string)table.Rows[0][0];
-            }
-        }
-
-        /// <summary>
-        /// Returns a list of user's logins
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public List<UserLoginInfo> FindByUserId(string userId)
-        {
-            List<UserLoginInfo> logins = new List<UserLoginInfo>();
-            string commandText = "Select * from UserLogins where UserId = @userId";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@userId", userId } };
-
-            var rows = _database.ExecuteCMD(commandText, parameters).Rows;
-            foreach (DataRow row in rows)
-            {
-                var login = new UserLoginInfo((string)row["LoginProvider"], (string)row["ProviderKey"], (string)row["LoginProvider"]);
-                logins.Add(login);
-            }
-
-            return logins;
-        }
-    }
-}

gaseous-server/Classes/Auth/Classes/UserRoleTable.cs

@@ -1,86 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that represents the UserRoles table in the MySQL Database
-    /// </summary>
-    public class UserRolesTable
-    {
-        private Database _database;
-
-        /// <summary>
-        /// Constructor that takes a MySQLDatabase instance 
-        /// </summary>
-        /// <param name="database"></param>
-        public UserRolesTable(Database database)
-        {
-            _database = database;
-        }
-
-        /// <summary>
-        /// Returns a list of user's roles
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public List<string> FindByUserId(string userId)
-        {
-            List<string> roles = new List<string>();
-            string commandText = "Select Roles.Name from UserRoles, Roles where UserRoles.UserId = @userId and UserRoles.RoleId = Roles.Id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@userId", userId);
-
-            var rows = _database.ExecuteCMD(commandText, parameters).Rows;
-            foreach (DataRow row in rows)
-            {
-                roles.Add((string)row["Name"]);
-            }
-
-            return roles;
-        }
-
-        /// <summary>
-        /// Deletes all roles from a user in the UserRoles table
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public int Delete(string userId)
-        {
-            string commandText = "Delete from UserRoles where UserId = @userId";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("UserId", userId);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        public int DeleteUserFromRole(string userId, string roleId)
-        {
-            string commandText = "Delete from UserRoles where UserId = @userId and RoleId = @roleId";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("userId", userId);
-            parameters.Add("roleId", roleId);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-
-        /// <summary>
-        /// Inserts a new role for a user in the UserRoles table
-        /// </summary>
-        /// <param name="user">The User</param>
-        /// <param name="roleId">The Role's id</param>
-        /// <returns></returns>
-        public int Insert(IdentityUser user, string roleId)
-        {
-            string commandText = "Insert into UserRoles (UserId, RoleId) values (@userId, @roleId)";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("userId", user.Id);
-            parameters.Add("roleId", roleId);
-
-            return (int)_database.ExecuteNonQuery(commandText, parameters);
-        }
-    }
-}

gaseous-server/Classes/Auth/Classes/UserStore.cs

@@ -1,616 +0,0 @@
-using System;
-using System.Security.Claims;
-using System.Threading.Tasks;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-using MySqlConnector;
-
-namespace Authentication
-{
-    public class UserStore : 
-        IUserStore<ApplicationUser>,
-        IUserRoleStore<ApplicationUser>,
-        IUserLoginStore<ApplicationUser>,
-        IUserClaimStore<ApplicationUser>,
-        IUserPasswordStore<ApplicationUser>,
-        IUserSecurityStampStore<ApplicationUser>,
-        IQueryableUserStore<ApplicationUser>,
-        IUserEmailStore<ApplicationUser>,
-        IUserPhoneNumberStore<ApplicationUser>,
-        IUserTwoFactorStore<ApplicationUser>,
-        IUserLockoutStore<ApplicationUser>
-    {
-        private Database database;
-
-        private UserTable<ApplicationUser> userTable;
-        private RoleTable roleTable;
-        private UserRolesTable userRolesTable;
-        private UserLoginsTable userLoginsTable;
-        private UserClaimsTable userClaimsTable;
-
-        public UserStore()
-        {
-            database = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            userTable = new UserTable<ApplicationUser>(database);
-            roleTable = new RoleTable(database);
-            userRolesTable = new UserRolesTable(database);
-            userLoginsTable = new UserLoginsTable(database);
-            userClaimsTable = new UserClaimsTable(database);
-        }
-
-        public UserStore(Database database)
-        {
-            this.database = database;
-            userTable = new UserTable<ApplicationUser>(database);
-            roleTable = new RoleTable(database);
-            userRolesTable = new UserRolesTable(database);
-            userLoginsTable = new UserLoginsTable(database);
-            userClaimsTable = new UserClaimsTable(database);
-        }
-
-        public IQueryable<ApplicationUser> Users
-        {
-            get
-            {
-                List<ApplicationUser> users = userTable.GetUsers();
-                return users.AsQueryable();
-            }
-        }
-
-        public Task AddClaimsAsync(ApplicationUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (claims == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            foreach (Claim claim in claims)
-            {
-                userClaimsTable.Insert(claim, user.Id);
-            }
-
-            return Task.FromResult<object>(null);
-        }
-
-        public Task AddLoginAsync(ApplicationUser user, UserLoginInfo login, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (login == null)
-            {
-                throw new ArgumentNullException("login");
-            }
-
-            userLoginsTable.Insert(user, login);
-
-            return Task.FromResult<object>(null);
-        }
-
-        public Task AddToRoleAsync(ApplicationUser user, string roleName, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (string.IsNullOrEmpty(roleName))
-            {
-                throw new ArgumentException("Argument cannot be null or empty: roleName.");
-            }
-
-            string roleId = roleTable.GetRoleId(roleName);
-            if (!string.IsNullOrEmpty(roleId))
-            {
-                userRolesTable.Insert(user, roleId);
-            }
-
-            return Task.FromResult<object>(null);
-        }
-
-        public Task<IdentityResult> CreateAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            userTable.Insert(user);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public Task<IdentityResult> DeleteAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user != null)
-            {
-                userTable.Delete(user);
-            }
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public void Dispose()
-        {
-            if (database != null)
-            {
-                database = null;
-            }
-        }
-
-        public Task<ApplicationUser?> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)
-        {
-            if (String.IsNullOrEmpty(normalizedEmail))
-            {
-                throw new ArgumentNullException("email");
-            }
-
-            ApplicationUser result = userTable.GetUserByEmail(normalizedEmail) as ApplicationUser;
-            if (result != null)
-            {
-                return Task.FromResult<ApplicationUser>(result);
-            }
-
-            return Task.FromResult<ApplicationUser>(null);
-        }
-
-        public Task<ApplicationUser?> FindByIdAsync(string userId, CancellationToken cancellationToken)
-        {
-            if (string.IsNullOrEmpty(userId))
-            {
-                throw new ArgumentException("Null or empty argument: userId");
-            }
-
-            ApplicationUser result = userTable.GetUserById(userId) as ApplicationUser;
-            if (result != null)
-            {
-                return Task.FromResult<ApplicationUser>(result);
-            }
-
-            return Task.FromResult<ApplicationUser>(null);
-        }
-
-        public Task<ApplicationUser?> FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)
-        {
-            if (loginProvider == null || providerKey == null)
-            {
-                throw new ArgumentNullException("login");
-            }
-
-            UserLoginInfo login = new UserLoginInfo(loginProvider, providerKey, loginProvider);
-
-            var userId = userLoginsTable.FindUserIdByLogin(login);
-            if (userId != null)
-            {
-                ApplicationUser user = userTable.GetUserById(userId) as ApplicationUser;
-                if (user != null)
-                {
-                    return Task.FromResult<ApplicationUser>(user);
-                }
-            }
-
-            return Task.FromResult<ApplicationUser>(null);
-        }
-
-        public Task<ApplicationUser?> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken)
-        {
-            if (string.IsNullOrEmpty(normalizedUserName))
-            {
-                throw new ArgumentException("Null or empty argument: normalizedUserName");
-            }
-
-            List<ApplicationUser> result = userTable.GetUserByName(normalizedUserName) as List<ApplicationUser>;
-
-            // Should I throw if > 1 user?
-            if (result != null && result.Count == 1)
-            {
-                return Task.FromResult<ApplicationUser>(result[0]);
-            }
-
-            return Task.FromResult<ApplicationUser>(null);
-        }
-
-        public Task<int> GetAccessFailedCountAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.AccessFailedCount);
-        }
-
-        public Task<IList<Claim>> GetClaimsAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            ClaimsIdentity identity = userClaimsTable.FindByUserId(user.Id);
-
-            return Task.FromResult<IList<Claim>>(identity.Claims.ToList());
-        }
-
-        public Task<string?> GetEmailAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.Email);
-        }
-
-        public Task<bool> GetEmailConfirmedAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.EmailConfirmed);
-        }
-
-        public Task<bool> GetLockoutEnabledAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.LockoutEnabled);
-        }
-
-        public Task<DateTimeOffset?> GetLockoutEndDateAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user.LockoutEnd.HasValue)
-            {
-                return Task.FromResult((DateTimeOffset?)user.LockoutEnd.Value);
-            }
-            else
-            {
-                return Task.FromResult((DateTimeOffset?)new DateTimeOffset());
-            }
-        }
-
-        public Task<IList<UserLoginInfo>> GetLoginsAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            List<UserLoginInfo> logins = userLoginsTable.FindByUserId(user.Id);
-            if (logins != null)
-            {
-                return Task.FromResult<IList<UserLoginInfo>>(logins);
-            }
-
-            return Task.FromResult<IList<UserLoginInfo>>(null);
-        }
-
-        public Task<string?> GetNormalizedEmailAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.NormalizedEmail);
-        }
-
-        public Task<string?> GetNormalizedUserNameAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user != null)
-            {
-                return Task.FromResult<string?>(userTable.GetUserName(user.Id));
-            }
-
-            return Task.FromResult<string?>(null);
-        }
-
-        public Task<string?> GetPasswordHashAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user != null)
-            {
-                return Task.FromResult<string?>(userTable.GetPasswordHash(user.Id));
-            }
-
-            return Task.FromResult<string?>(null);
-        }
-
-        public Task<string?> GetPhoneNumberAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.PhoneNumber);
-        }
-
-        public Task<bool> GetPhoneNumberConfirmedAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.PhoneNumberConfirmed);
-        }
-
-        public Task<IList<string>> GetRolesAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            List<string> roles = userRolesTable.FindByUserId(user.Id);
-            {
-                if (roles != null)
-                {
-                    return Task.FromResult<IList<string>>(roles);
-                }
-            }
-
-            return Task.FromResult<IList<string>>(null);
-        }
-
-        public Task<string?> GetSecurityStampAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.SecurityStamp);
-        }
-
-        public Task<bool> GetTwoFactorEnabledAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            return Task.FromResult(user.TwoFactorEnabled);
-        }
-
-        public Task<string> GetUserIdAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user != null)
-            {
-                return Task.FromResult<string>(userTable.GetUserId(user.NormalizedUserName));
-            }
-
-            return Task.FromResult<string>(null);
-        }
-
-        public Task<string?> GetUserNameAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user != null)
-            {
-                //return Task.FromResult<string?>(userTable.GetUserName(user.Id));
-                return Task.FromResult(user.UserName);
-            }
-
-            return Task.FromResult<string?>(null);
-        }
-
-        public Task<IList<ApplicationUser>> GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<IList<ApplicationUser>> GetUsersInRoleAsync(string roleName, CancellationToken cancellationToken)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> HasPasswordAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            var hasPassword = !string.IsNullOrEmpty(userTable.GetPasswordHash(user.Id));
-
-            return Task.FromResult<bool>(Boolean.Parse(hasPassword.ToString()));
-        }
-
-        public Task<int> IncrementAccessFailedCountAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            user.AccessFailedCount++;
-            userTable.Update(user);
-
-            return Task.FromResult(user.AccessFailedCount);
-        }
-
-        public Task<bool> IsInRoleAsync(ApplicationUser user, string roleName, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (string.IsNullOrEmpty(roleName))
-            {
-                throw new ArgumentNullException("role");
-            }
-
-            List<string> roles = userRolesTable.FindByUserId(user.Id);
-            {
-                if (roles != null)
-                {
-                    foreach (string role in roles)
-                    {
-                        if (role.ToUpper() == roleName.ToUpper())
-                        {
-                            return Task.FromResult<bool>(true);
-                        }
-                    }
-                }
-            }
-
-            return Task.FromResult<bool>(false);
-        }
-
-        public Task RemoveClaimsAsync(ApplicationUser user, IEnumerable<Claim> claims, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (claims == null)
-            {
-                throw new ArgumentNullException("claim");
-            }
-
-            foreach (Claim claim in claims)
-            {
-                userClaimsTable.Delete(user, claim);
-            }
-
-            return Task.FromResult<object>(null);
-        }
-
-        public Task RemoveFromRoleAsync(ApplicationUser user, string roleName, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (roleName == null)
-            {
-                throw new ArgumentNullException("role");
-            }
-
-            IdentityRole? role = roleTable.GetRoleByName(roleName);
-
-            if (role != null)
-            {
-                userRolesTable.DeleteUserFromRole(user.Id, role.Id);
-            }
-
-            return Task.FromResult<Object>(null);
-        }
-
-        public Task RemoveLoginAsync(ApplicationUser user, string loginProvider, string providerKey, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (loginProvider == null || providerKey == null)
-            {
-                throw new ArgumentNullException("login");
-            }
-
-            UserLoginInfo login = new UserLoginInfo(loginProvider, providerKey, loginProvider);
-
-            userLoginsTable.Delete(user, login);
-
-            return Task.FromResult<Object>(null);
-        }
-
-        public Task ReplaceClaimAsync(ApplicationUser user, Claim claim, Claim newClaim, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            if (claim == null || newClaim == null)
-            {
-                throw new ArgumentNullException("claim");
-            }
-
-            userClaimsTable.Delete(user, claim);
-            userClaimsTable.Insert(newClaim, user.Id);
-
-            return Task.FromResult<Object>(null);
-        }
-
-        public Task ResetAccessFailedCountAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            user.AccessFailedCount = 0;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetEmailAsync(ApplicationUser user, string? email, CancellationToken cancellationToken)
-        {
-            user.Email = email;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetEmailConfirmedAsync(ApplicationUser user, bool confirmed, CancellationToken cancellationToken)
-        {
-            user.EmailConfirmed = confirmed;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetLockoutEnabledAsync(ApplicationUser user, bool enabled, CancellationToken cancellationToken)
-        {
-            user.LockoutEnabled = enabled;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetLockoutEndDateAsync(ApplicationUser user, DateTimeOffset? lockoutEnd, CancellationToken cancellationToken)
-        {
-            user.LockoutEnd = lockoutEnd;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetNormalizedEmailAsync(ApplicationUser user, string? normalizedEmail, CancellationToken cancellationToken)
-        {
-            user.NormalizedEmail = normalizedEmail;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetNormalizedUserNameAsync(ApplicationUser user, string? normalizedName, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            user.NormalizedUserName = normalizedName;
-            userTable.Update(user);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public Task SetPasswordHashAsync(ApplicationUser user, string? passwordHash, CancellationToken cancellationToken)
-        {
-            user.PasswordHash = passwordHash;
-
-            return Task.FromResult<Object>(null);
-        }
-
-        public Task SetPhoneNumberAsync(ApplicationUser user, string? phoneNumber, CancellationToken cancellationToken)
-        {
-            user.PhoneNumber = phoneNumber;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetPhoneNumberConfirmedAsync(ApplicationUser user, bool confirmed, CancellationToken cancellationToken)
-        {
-            user.PhoneNumberConfirmed = confirmed;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetSecurityStampAsync(ApplicationUser user, string stamp, CancellationToken cancellationToken)
-        {
-            user.SecurityStamp = stamp;
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetTwoFactorEnabledAsync(ApplicationUser user, bool enabled, CancellationToken cancellationToken)
-        {
-            user.TwoFactorEnabled = enabled;
-            userTable.Update(user);
-
-            return Task.FromResult(0);
-        }
-
-        public Task SetUserNameAsync(ApplicationUser user, string? userName, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            user.UserName = userName;
-            userTable.Update(user);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-
-        public Task<IdentityResult> UpdateAsync(ApplicationUser user, CancellationToken cancellationToken)
-        {
-            if (user == null)
-            {
-                throw new ArgumentNullException("user");
-            }
-
-            userTable.Update(user);
-
-            return Task.FromResult<IdentityResult>(IdentityResult.Success);
-        }
-    }
-}

gaseous-server/Classes/Auth/Classes/UserTable.cs

@@ -1,470 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Identity;
-
-namespace Authentication
-{
-    /// <summary>
-    /// Class that represents the Users table in the MySQL Database
-    /// </summary>
-    public class UserTable<TUser>
-        where TUser : ApplicationUser
-    {
-        private Database _database;
-
-        /// <summary>
-        /// Constructor that takes a MySQLDatabase instance 
-        /// </summary>
-        /// <param name="database"></param>
-        public UserTable(Database database)
-        {
-            _database = database;
-        }
-
-        /// <summary>
-        /// Returns the user's name given a user id
-        /// </summary>
-        /// <param name="userId"></param>
-        /// <returns></returns>
-        public string? GetUserName(string userId)
-        {
-            string commandText = "Select NormalizedUserName from Users where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@id", userId } };
-
-            DataTable table = _database.ExecuteCMD(commandText, parameters);
-
-            if (table.Rows.Count == 0)
-            {
-                return null;
-            }
-            else
-            {
-                return (string)table.Rows[0][0];
-            }
-        }
-
-        /// <summary>
-        /// Returns a User ID given a user name
-        /// </summary>
-        /// <param name="userName">The user's name</param>
-        /// <returns></returns>
-        public string? GetUserId(string normalizedUserName)
-        {
-            string commandText = "Select Id from Users where NormalizedUserName = @name";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@name", normalizedUserName } };
-
-            DataTable table = _database.ExecuteCMD(commandText, parameters);
-
-            if (table.Rows.Count == 0)
-            {
-                return null;
-            }
-            else
-            {
-                return (string)table.Rows[0][0];
-            }
-        }
-
-        /// <summary>
-        /// Returns an TUser given the user's id
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public TUser GetUserById(string userId)
-        {
-            TUser user = null;
-            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@id", userId } };
-
-            var rows = _database.ExecuteCMDDict(commandText, parameters);
-            if (rows != null && rows.Count == 1)
-            {
-                Dictionary<string, object> row = rows[0];
-                user = (TUser)Activator.CreateInstance(typeof(TUser));
-                user.Id = (string)row["Id"];
-                user.UserName = (string?)row["UserName"];
-                user.PasswordHash = (string?)(string.IsNullOrEmpty((string?)row["PasswordHash"]) ? null : row["PasswordHash"]);
-                user.SecurityStamp = (string?)(string.IsNullOrEmpty((string?)row["SecurityStamp"]) ? null : row["SecurityStamp"]);
-                user.ConcurrencyStamp = (string?)(string.IsNullOrEmpty((string?)row["ConcurrencyStamp"]) ? null : row["ConcurrencyStamp"]);
-                user.Email = (string?)(string.IsNullOrEmpty((string?)row["Email"]) ? null : row["Email"]);
-                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true : false;
-                user.PhoneNumber = (string?)(string.IsNullOrEmpty((string?)row["PhoneNumber"]) ? null : row["PhoneNumber"]);
-                user.PhoneNumberConfirmed = row["PhoneNumberConfirmed"] == "1" ? true : false;
-                user.NormalizedEmail = (string?)(string.IsNullOrEmpty((string?)row["NormalizedEmail"]) ? null : row["NormalizedEmail"]);
-                user.NormalizedUserName = (string?)(string.IsNullOrEmpty((string?)row["NormalizedUserName"]) ? null : row["NormalizedUserName"]);
-                user.LockoutEnabled = row["LockoutEnabled"] == "1" ? true : false;
-                user.LockoutEnd = string.IsNullOrEmpty((string?)row["LockoutEnd"]) ? DateTime.Now : DateTime.Parse((string?)row["LockoutEnd"]);
-                user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
-                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
-                user.SecurityProfile = GetSecurityProfile(user);
-                user.UserPreferences = GetPreferences(user);
-                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
-            }
-
-            return user;
-        }
-
-        /// <summary>
-        /// Returns a list of TUser instances given a user name
-        /// </summary>
-        /// <param name="normalizedUserName">User's name</param>
-        /// <returns></returns>
-        public List<TUser> GetUserByName(string normalizedUserName)
-        {
-            List<TUser> users = new List<TUser>();
-            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId where NormalizedEmail = @name";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@name", normalizedUserName } };
-
-            var rows = _database.ExecuteCMDDict(commandText, parameters);
-            foreach (Dictionary<string, object> row in rows)
-            {
-                TUser user = (TUser)Activator.CreateInstance(typeof(TUser));
-                user.Id = (string)row["Id"];
-                user.UserName = (string?)row["UserName"];
-                user.PasswordHash = (string?)(string.IsNullOrEmpty((string?)row["PasswordHash"]) ? null : row["PasswordHash"]);
-                user.SecurityStamp = (string?)(string.IsNullOrEmpty((string?)row["SecurityStamp"]) ? null : row["SecurityStamp"]);
-                user.ConcurrencyStamp = (string?)(string.IsNullOrEmpty((string?)row["ConcurrencyStamp"]) ? null : row["ConcurrencyStamp"]);
-                user.Email = (string?)(string.IsNullOrEmpty((string?)row["Email"]) ? null : row["Email"]);
-                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true : false;
-                user.PhoneNumber = (string?)(string.IsNullOrEmpty((string?)row["PhoneNumber"]) ? null : row["PhoneNumber"]);
-                user.PhoneNumberConfirmed = row["PhoneNumberConfirmed"] == "1" ? true : false;
-                user.NormalizedEmail = (string?)(string.IsNullOrEmpty((string?)row["NormalizedEmail"]) ? null : row["NormalizedEmail"]);
-                user.NormalizedUserName = (string?)(string.IsNullOrEmpty((string?)row["NormalizedUserName"]) ? null : row["NormalizedUserName"]);
-                user.LockoutEnabled = row["LockoutEnabled"] == "1" ? true : false;
-                user.LockoutEnd = string.IsNullOrEmpty((string?)row["LockoutEnd"]) ? DateTime.Now : DateTime.Parse((string?)row["LockoutEnd"]);
-                user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
-                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
-                user.SecurityProfile = GetSecurityProfile(user);
-                user.UserPreferences = GetPreferences(user);
-                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
-                users.Add(user);
-            }
-
-            return users;
-        }
-
-        public List<TUser> GetUsers()
-        {
-            List<TUser> users = new List<TUser>();
-            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId order by NormalizedUserName";
-
-            var rows = _database.ExecuteCMDDict(commandText);
-            foreach (Dictionary<string, object> row in rows)
-            {
-                TUser user = (TUser)Activator.CreateInstance(typeof(TUser));
-                user.Id = (string)row["Id"];
-                user.UserName = (string?)row["UserName"];
-                user.PasswordHash = (string?)(string.IsNullOrEmpty((string?)row["PasswordHash"]) ? null : row["PasswordHash"]);
-                user.SecurityStamp = (string?)(string.IsNullOrEmpty((string?)row["SecurityStamp"]) ? null : row["SecurityStamp"]);
-                user.ConcurrencyStamp = (string?)(string.IsNullOrEmpty((string?)row["ConcurrencyStamp"]) ? null : row["ConcurrencyStamp"]);
-                user.Email = (string?)(string.IsNullOrEmpty((string?)row["Email"]) ? null : row["Email"]);
-                user.EmailConfirmed = row["EmailConfirmed"] == "1" ? true : false;
-                user.PhoneNumber = (string?)(string.IsNullOrEmpty((string?)row["PhoneNumber"]) ? null : row["PhoneNumber"]);
-                user.PhoneNumberConfirmed = row["PhoneNumberConfirmed"] == "1" ? true : false;
-                user.NormalizedEmail = (string?)(string.IsNullOrEmpty((string?)row["NormalizedEmail"]) ? null : row["NormalizedEmail"]);
-                user.NormalizedUserName = (string?)(string.IsNullOrEmpty((string?)row["NormalizedUserName"]) ? null : row["NormalizedUserName"]);
-                user.LockoutEnabled = row["LockoutEnabled"] == "1" ? true : false;
-                user.LockoutEnd = string.IsNullOrEmpty((string?)row["LockoutEnd"]) ? DateTime.Now : DateTime.Parse((string?)row["LockoutEnd"]);
-                user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
-                user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
-                user.SecurityProfile = GetSecurityProfile(user);
-                user.UserPreferences = GetPreferences(user);
-                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
-                users.Add(user);
-            }
-
-            return users;
-        }
-
-        public TUser GetUserByEmail(string email)
-        {
-            List<TUser> users = GetUserByName(email);
-            if (users.Count == 0)
-            {
-                return null;
-            }
-            else
-            {
-                return users[0];
-            }
-        }
-
-        /// <summary>
-        /// Return the user's password hash
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        public string GetPasswordHash(string userId)
-        {
-            string commandText = "Select PasswordHash from Users where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@id", userId);
-
-            DataTable table = _database.ExecuteCMD(commandText, parameters);
-
-            if (table.Rows.Count == 0)
-            {
-                return null;
-            }
-            else
-            {
-                return (string)table.Rows[0][0];
-            }
-        }
-
-        /// <summary>
-        /// Sets the user's password hash
-        /// </summary>
-        /// <param name="userId"></param>
-        /// <param name="passwordHash"></param>
-        /// <returns></returns>
-        public int SetPasswordHash(string userId, string passwordHash)
-        {
-            string commandText = "Update Users set PasswordHash = @pwdHash where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@pwdHash", passwordHash);
-            parameters.Add("@id", userId);
-
-            return _database.ExecuteCMD(commandText, parameters).Rows.Count;
-        }
-
-        /// <summary>
-        /// Returns the user's security stamp
-        /// </summary>
-        /// <param name="userId"></param>
-        /// <returns></returns>
-        public string GetSecurityStamp(string userId)
-        {
-            string commandText = "Select SecurityStamp from Users where Id = @id";
-            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@id", userId } };
-            DataTable table = _database.ExecuteCMD(commandText, parameters);
-
-            if (table.Rows.Count == 0)
-            {
-                return null;
-            }
-            else
-            {
-                return (string)table.Rows[0][0];
-            }
-        }
-
-        /// <summary>
-        /// Inserts a new user in the Users table
-        /// </summary>
-        /// <param name="user"></param>
-        /// <returns></returns>
-        public int Insert(TUser user)
-        {
-            string commandText = @"Insert into Users (UserName, Id, PasswordHash, SecurityStamp, ConcurrencyStamp, Email, EmailConfirmed, PhoneNumber, PhoneNumberConfirmed, NormalizedEmail, NormalizedUserName, AccessFailedCount, LockoutEnabled, LockoutEnd, TwoFactorEnabled) values (@name, @id, @pwdHash, @SecStamp, @concurrencystamp, @email ,@emailconfirmed ,@phonenumber, @phonenumberconfirmed, @normalizedemail, @normalizedusername, @accesscount, @lockoutenabled, @lockoutenddate, @twofactorenabled); Insert into UserProfiles (Id, UserId, DisplayName, Quip, UnstructuredData) values (@profileId, @id, @email, '', '{}');";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@name", user.UserName);
-            parameters.Add("@id", user.Id);
-            parameters.Add("@profileId", Guid.NewGuid());
-            parameters.Add("@pwdHash", user.PasswordHash);
-            parameters.Add("@SecStamp", user.SecurityStamp);
-            parameters.Add("@concurrencystamp", user.ConcurrencyStamp);
-            parameters.Add("@email", user.Email);
-            parameters.Add("@emailconfirmed", user.EmailConfirmed);
-            parameters.Add("@phonenumber", user.PhoneNumber);
-            parameters.Add("@phonenumberconfirmed", user.PhoneNumberConfirmed);
-            parameters.Add("@normalizedemail", user.NormalizedEmail);
-            parameters.Add("@normalizedusername", user.NormalizedUserName);
-            parameters.Add("@accesscount", user.AccessFailedCount);
-            parameters.Add("@lockoutenabled", user.LockoutEnabled);
-            parameters.Add("@lockoutenddate", user.LockoutEnd);
-            parameters.Add("@twofactorenabled", user.TwoFactorEnabled);
-
-            // set default security profile
-            SetSecurityProfile(user, new SecurityProfileViewModel());
-
-            // set default preferences
-            SetPreferences(user, new List<UserPreferenceViewModel>());
-
-            return _database.ExecuteCMD(commandText, parameters).Rows.Count;
-        }
-
-        /// <summary>
-        /// Deletes a user from the Users table
-        /// </summary>
-        /// <param name="userId">The user's id</param>
-        /// <returns></returns>
-        private int Delete(string userId)
-        {
-            string commandText = "Delete from Users where Id = @userId; Delete from User_Settings where Id = @userId; Delete from UserProfiles where UserId = @userId; Delete from GameState where UserId = @userId;";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@userId", userId);
-
-            return _database.ExecuteCMD(commandText, parameters).Rows.Count;
-        }
-
-        /// <summary>
-        /// Deletes a user from the Users table
-        /// </summary>
-        /// <param name="user"></param>
-        /// <returns></returns>
-        public int Delete(TUser user)
-        {
-            return Delete(user.Id);
-        }
-
-        /// <summary>
-        /// Updates a user in the Users table
-        /// </summary>
-        /// <param name="user"></param>
-        /// <returns></returns>
-        public int Update(TUser user)
-        {
-            string commandText = @"Update Users set UserName = @userName, PasswordHash = @pwdHash, SecurityStamp = @secStamp, ConcurrencyStamp = @concurrencystamp, Email = @email, EmailConfirmed = @emailconfirmed, PhoneNumber = @phonenumber, PhoneNumberConfirmed = @phonenumberconfirmed, NormalizedEmail = @normalizedemail, NormalizedUserName = @normalizedusername, AccessFailedCount = @accesscount, LockoutEnabled = @lockoutenabled, LockoutEnd = @lockoutenddate, TwoFactorEnabled=@twofactorenabled WHERE Id = @userId;";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@userId", user.Id);
-            parameters.Add("@userName", user.UserName);
-            parameters.Add("@pwdHash", user.PasswordHash);
-            parameters.Add("@SecStamp", user.SecurityStamp);
-            parameters.Add("@concurrencystamp", user.ConcurrencyStamp);
-            parameters.Add("@email", user.Email);
-            parameters.Add("@emailconfirmed", user.EmailConfirmed);
-            parameters.Add("@phonenumber", user.PhoneNumber);
-            parameters.Add("@phonenumberconfirmed", user.PhoneNumberConfirmed);
-            parameters.Add("@normalizedemail", user.NormalizedEmail);
-            parameters.Add("@normalizedusername", user.NormalizedUserName);
-            parameters.Add("@accesscount", user.AccessFailedCount);
-            parameters.Add("@lockoutenabled", user.LockoutEnabled);
-            parameters.Add("@lockoutenddate", user.LockoutEnd);
-            parameters.Add("@twofactorenabled", user.TwoFactorEnabled);
-
-            // set the security profile
-            SetSecurityProfile(user, user.SecurityProfile);
-
-            // set preferences
-            SetPreferences(user, user.UserPreferences);
-
-            return _database.ExecuteCMD(commandText, parameters).Rows.Count;
-        }
-
-        private SecurityProfileViewModel GetSecurityProfile(TUser user)
-        {
-            string sql = "SELECT SecurityProfile FROM Users WHERE Id=@Id;";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("Id", user.Id);
-
-            List<Dictionary<string, object>> data = _database.ExecuteCMDDict(sql, dbDict);
-            if (data.Count == 0)
-            {
-                // no saved profile - return the default one
-                return new SecurityProfileViewModel();
-            }
-            else
-            {
-                string? securityProfileString = (string?)data[0]["SecurityProfile"];
-                if (securityProfileString != null && securityProfileString != "null")
-                {
-                    SecurityProfileViewModel securityProfile = Newtonsoft.Json.JsonConvert.DeserializeObject<SecurityProfileViewModel>(securityProfileString);
-                    return securityProfile;
-                }
-                else
-                {
-                    return new SecurityProfileViewModel();
-                }
-            }
-        }
-
-        private int SetSecurityProfile(TUser user, SecurityProfileViewModel securityProfile)
-        {
-            string commandText = "UPDATE Users SET SecurityProfile=@SecurityProfile WHERE Id=@Id;";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("Id", user.Id);
-            parameters.Add("SecurityProfile", Newtonsoft.Json.JsonConvert.SerializeObject(securityProfile));
-
-            return _database.ExecuteCMD(commandText, parameters).Rows.Count;
-        }
-
-        public List<UserPreferenceViewModel> GetPreferences(TUser user)
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT `Setting`, `Value` FROM User_Settings WHERE Id=@id;";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("id", user.Id);
-
-            DataTable data = db.ExecuteCMD(sql, dbDict);
-
-            List<UserPreferenceViewModel> userPrefs = new List<UserPreferenceViewModel>();
-            foreach (DataRow row in data.Rows)
-            {
-                UserPreferenceViewModel userPref = new UserPreferenceViewModel();
-                userPref.Setting = (string)row["Setting"];
-                userPref.Value = (string)row["Value"];
-                userPrefs.Add(userPref);
-            }
-
-            return userPrefs;
-        }
-
-        public int SetPreferences(TUser user, List<UserPreferenceViewModel> model)
-        {
-            if (model != null)
-            {
-                List<UserPreferenceViewModel> userPreferences = GetPreferences(user);
-
-                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-                foreach (UserPreferenceViewModel modelItem in model)
-                {
-                    bool prefItemFound = false;
-                    foreach (UserPreferenceViewModel existing in userPreferences)
-                    {
-                        if (existing.Setting.ToLower() == modelItem.Setting.ToLower())
-                        {
-                            prefItemFound = true;
-                            break;
-                        }
-                    }
-
-                    string sql = "INSERT INTO User_Settings (`Id`, `Setting`, `Value`) VALUES (@id, @setting, @value);";
-                    if (prefItemFound == true)
-                    {
-                        sql = "UPDATE User_Settings SET `Value`=@value WHERE `Id`=@id AND `Setting`=@setting";
-                    }
-                    Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                    dbDict.Add("id", user.Id);
-                    dbDict.Add("setting", modelItem.Setting);
-                    dbDict.Add("value", modelItem.Value);
-                    db.ExecuteNonQuery(sql, dbDict);
-                }
-
-                return model.Count;
-            }
-            else
-            {
-                return 0;
-            }
-        }
-
-        public Guid SetAvatar(TUser user, byte[] bytes)
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql;
-            Dictionary<string, object> dbDict = new Dictionary<string, object>
-            {
-                { "userid", user.Id }
-            };
-
-            if (bytes.Length == 0)
-            {
-                sql = "DELETE FROM UserAvatars WHERE UserId = @userid";
-                db.ExecuteNonQuery(sql, dbDict);
-                return Guid.Empty;
-            }
-            else
-            {
-                sql = "DELETE FROM UserAvatars WHERE UserId = @userid; INSERT INTO UserAvatars (UserId, Id, Avatar) VALUES (@userid, @id, @avatar);";
-                dbDict.Add("id", Guid.NewGuid());
-                dbDict.Add("avatar", bytes);
-                db.ExecuteNonQuery(sql, dbDict);
-                return (Guid)dbDict["id"];
-            }
-        }
-    }
-}

gaseous-server/Classes/Auth/Models/AccountViewModels.cs

@@ -1,100 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication
-{
-    public class ExternalLoginConfirmationViewModel
-    {
-        [Required]
-        [EmailAddress]
-        [Display(Name = "Email")]
-        public string Email { get; set; }
-    }
-
-    public class ManageUserViewModel
-    {
-        [Required]
-        [DataType(DataType.Password)]
-        [Display(Name = "Current password")]
-        public string OldPassword { get; set; }
-
-        [Required]
-        [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)]
-        [DataType(DataType.Password)]
-        [Display(Name = "New password")]
-        public string NewPassword { get; set; }
-
-        [DataType(DataType.Password)]
-        [Display(Name = "Confirm new password")]
-        [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")]
-        public string ConfirmPassword { get; set; }
-    }
-
-    public class LoginViewModel
-    {
-        [Required]
-        [EmailAddress]
-        [Display(Name = "Email")]
-        public string Email { get; set; }
-
-        [Required]
-        [DataType(DataType.Password)]
-        [Display(Name = "Password")]
-        public string Password { get; set; }
-
-        [Display(Name = "Remember me?")]
-        public bool RememberMe { get; set; }
-    }
-
-    public class RegisterViewModel
-    {
-        [Required]
-        [DataType(DataType.Text)]
-        [Display(Name = "User name")]
-        public string UserName { get; set; }
-
-        [Required]
-        [EmailAddress]
-        [Display(Name = "Email")]
-        public string Email { get; set; }
-
-        [Required]
-        [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)]
-        [DataType(DataType.Password)]
-        [Display(Name = "Password")]
-        public string Password { get; set; }
-
-        [DataType(DataType.Password)]
-        [Display(Name = "Confirm password")]
-        [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
-        public string ConfirmPassword { get; set; }
-    }
-
-    public class ResetPasswordViewModel
-    {
-        [Required]
-        [EmailAddress]
-        [Display(Name = "Email")]
-        public string Email { get; set; }
-
-        [Required]
-        [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)]
-        [DataType(DataType.Password)]
-        [Display(Name = "Password")]
-        public string Password { get; set; }
-
-        [DataType(DataType.Password)]
-        [Display(Name = "Confirm password")]
-        [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
-        public string ConfirmPassword { get; set; }
-
-        public string Code { get; set; }
-    }
-
-    public class ForgotPasswordViewModel
-    {
-        [Required]
-        [EmailAddress]
-        [Display(Name = "Email")]
-        public string Email { get; set; }
-    }
-}

gaseous-server/Classes/Auth/Models/AddPhoneNumberViewModel.cs

@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class AddPhoneNumberViewModel
-{
-    [Required]
-    [Phone]
-    [Display(Name = "Phone number")]
-    public string PhoneNumber { get; set; }
-}

gaseous-server/Classes/Auth/Models/ChangePasswordViewModel.cs

@@ -1,25 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class ChangePasswordViewModel
-{
-    [Required]
-    [DataType(DataType.Password)]
-    [Display(Name = "Current password")]
-    public string OldPassword { get; set; }
-
-    [Required]
-    [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 10)]
-    [DataType(DataType.Password)]
-    [Display(Name = "New password")]
-    public string NewPassword { get; set; }
-
-    [DataType(DataType.Password)]
-    [Display(Name = "Confirm new password")]
-    [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")]
-    public string ConfirmPassword { get; set; }
-}

gaseous-server/Classes/Auth/Models/DisplayRecoveryCodesViewModel.cs

@@ -1,13 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class DisplayRecoveryCodesViewModel
-{
-    [Required]
-    public IEnumerable<string> Codes { get; set; }
-
-}

gaseous-server/Classes/Auth/Models/IndexViewModel.cs

@@ -1,21 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.AspNetCore.Identity;
-
-namespace Authentication;
-
-public class IndexViewModel
-{
-    public bool HasPassword { get; set; }
-
-    public IList<UserLoginInfo> Logins { get; set; }
-
-    public string PhoneNumber { get; set; }
-
-    public bool TwoFactor { get; set; }
-
-    public bool BrowserRemembered { get; set; }
-
-    public string AuthenticatorKey { get; set; }
-}

gaseous-server/Classes/Auth/Models/ManageLoginsViewModel.cs

@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.AspNetCore.Authentication;
-using Microsoft.AspNetCore.Identity;
-
-namespace Authentication;
-
-public class ManageLoginsViewModel
-{
-    public IList<UserLoginInfo> CurrentLogins { get; set; }
-
-    public IList<AuthenticationScheme> OtherLogins { get; set; }
-}

gaseous-server/Classes/Auth/Models/ProfileViewModel.cs

@@ -1,49 +0,0 @@
-namespace Authentication
-{
-    public class ProfileBasicViewModel
-    {
-        public string UserId { get; set; }
-        public string UserName { get; set; }
-        public string EmailAddress { get; set; }
-        public List<String> Roles { get; set; }
-        public SecurityProfileViewModel SecurityProfile { get; set; }
-        public List<UserPreferenceViewModel> UserPreferences { get; set; }
-        public Guid ProfileId { get; set; }
-        public string HighestRole
-        {
-            get
-            {
-                string _highestRole = "";
-                foreach (string role in Roles)
-                {
-                    switch (role)
-                    {
-                        case "Admin":
-                            // there is no higher
-                            _highestRole = role;
-                            break;
-                        case "Gamer":
-                            // only one high is Admin, so check for that
-                            if (_highestRole != "Admin")
-                            {
-                                _highestRole = role;
-                            }
-                            break;
-                        case "Player":
-                            // make sure _highestRole isn't already set to Gamer or Admin
-                            if (_highestRole != "Admin" && _highestRole != "Gamer")
-                            {
-                                _highestRole = role;
-                            }
-                            break;
-                        default:
-                            _highestRole = "Player";
-                            break;
-                    }
-                }
-
-                return _highestRole;
-            }
-        }
-    }
-}

gaseous-server/Classes/Auth/Models/RemoveLoginViewModel.cs

@@ -1,10 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-namespace Authentication;
-
-public class RemoveLoginViewModel
-{
-    public string LoginProvider { get; set; }
-    public string ProviderKey { get; set; }
-}

gaseous-server/Classes/Auth/Models/SecurityProfileViewModel.cs

@@ -1,18 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication
-{
-    public class SecurityProfileViewModel
-    {
-        public AgeRestrictionItem AgeRestrictionPolicy { get; set; } = new AgeRestrictionItem{ 
-            MaximumAgeRestriction = gaseous_server.Classes.Metadata.AgeGroups.AgeRestrictionGroupings.Adult,
-            IncludeUnrated = true 
-        };
-
-        public class AgeRestrictionItem
-        {
-            public gaseous_server.Classes.Metadata.AgeGroups.AgeRestrictionGroupings MaximumAgeRestriction { get; set; }
-            public bool IncludeUnrated { get; set; }
-        }
-    }
-}

gaseous-server/Classes/Auth/Models/SendCodeViewModel.cs

@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using Microsoft.AspNetCore.Mvc.Rendering;
-
-namespace Authentication;
-
-public class SendCodeViewModel
-{
-    public string SelectedProvider { get; set; }
-
-    public ICollection<SelectListItem> Providers { get; set; }
-
-    public string ReturnUrl { get; set; }
-
-    public bool RememberMe { get; set; }
-}

gaseous-server/Classes/Auth/Models/SetPasswordViewModel.cs

@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class SetPasswordViewModel
-{
-    [Required]
-    [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)]
-    [DataType(DataType.Password)]
-    [Display(Name = "New password")]
-    public string NewPassword { get; set; }
-
-    [DataType(DataType.Password)]
-    [Display(Name = "Confirm new password")]
-    [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")]
-    public string ConfirmPassword { get; set; }
-}

gaseous-server/Classes/Auth/Models/UseRecoveryCodeViewModel.cs

@@ -1,14 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class UseRecoveryCodeViewModel
-{
-    [Required]
-    public string Code { get; set; }
-
-    public string ReturnUrl { get; set; }
-}

gaseous-server/Classes/Auth/Models/UserPreferenceViewModels.cs

@@ -1,8 +0,0 @@
-namespace Authentication;
-
-public class UserPreferenceViewModel
-{
-    public string Setting { get; set; }
-
-    public string Value { get; set; }
-}

gaseous-server/Classes/Auth/Models/UserViewModel.cs

@@ -1,56 +0,0 @@
-namespace Authentication
-{
-    public class UserViewModel
-    {
-        public string Id { get; set; }
-        public string EmailAddress { get; set; }
-        public bool LockoutEnabled { get; set; }
-        public DateTimeOffset? LockoutEnd { get; set; }
-        public List<string> Roles { get; set; }
-        public SecurityProfileViewModel SecurityProfile { get; set; }
-        public Guid ProfileId { get; set; }
-        public string HighestRole
-        {
-            get
-            {
-                string _highestRole = "";
-                if (Roles != null)
-                {
-                    foreach (string role in Roles)
-                    {
-                        switch (role)
-                        {
-                            case "Admin":
-                                // there is no higher
-                                _highestRole = role;
-                                break;
-                            case "Gamer":
-                                // only one high is Admin, so check for that
-                                if (_highestRole != "Admin")
-                                {
-                                    _highestRole = role;
-                                }
-                                break;
-                            case "Player":
-                                // make sure _highestRole isn't already set to Gamer or Admin
-                                if (_highestRole != "Admin" && _highestRole != "Gamer")
-                                {
-                                    _highestRole = role;
-                                }
-                                break;
-                            default:
-                                _highestRole = "Player";
-                                break;
-                        }
-                    }
-                }
-                else
-                {
-                    _highestRole = "Player";
-                }
-
-                return _highestRole;
-            }
-        }
-    }
-}

gaseous-server/Classes/Auth/Models/VerifyAuthenticatorCodeViewModel.cs

@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class VerifyAuthenticatorCodeViewModel
-{
-    [Required]
-    public string Code { get; set; }
-
-    public string ReturnUrl { get; set; }
-
-    [Display(Name = "Remember this browser?")]
-    public bool RememberBrowser { get; set; }
-
-    [Display(Name = "Remember me?")]
-    public bool RememberMe { get; set; }
-}

gaseous-server/Classes/Auth/Models/VerifyCodeViewModel.cs

@@ -1,23 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class VerifyCodeViewModel
-{
-    [Required]
-    public string Provider { get; set; }
-
-    [Required]
-    public string Code { get; set; }
-
-    public string ReturnUrl { get; set; }
-
-    [Display(Name = "Remember this browser?")]
-    public bool RememberBrowser { get; set; }
-
-    [Display(Name = "Remember me?")]
-    public bool RememberMe { get; set; }
-}

gaseous-server/Classes/Auth/Models/VerifyPhoneNumberViewModel.cs

@@ -1,17 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.ComponentModel.DataAnnotations;
-
-namespace Authentication;
-
-public class VerifyPhoneNumberViewModel
-{
-    [Required]
-    public string Code { get; set; }
-
-    [Required]
-    [Phone]
-    [Display(Name = "Phone number")]
-    public string PhoneNumber { get; set; }
-}

gaseous-server/Classes/Bios.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
+using gaseous_tools;
 
 namespace gaseous_server.Classes
 {
@@ -11,33 +12,6 @@ namespace gaseous_server.Classes
             
 		}
 
-        public static void MigrateToNewFolderStructure()
-        {
-            // migrate from old BIOS file structure which had each bios file inside a folder named for the platform to the new structure which has each file in a subdirectory named after the MD5 hash
-            if (Directory.Exists(Config.LibraryConfiguration.LibraryBIOSDirectory))
-            {
-                foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
-                {
-                    if (platformMapping.Bios != null)
-                    {
-                        foreach (Models.PlatformMapping.PlatformMapItem.EmulatorBiosItem emulatorBiosItem in platformMapping.Bios)
-                        {
-                            string oldBiosPath = Path.Combine(Config.LibraryConfiguration.LibraryBIOSDirectory, platformMapping.IGDBSlug.ToString(), emulatorBiosItem.filename);
-                            string newBiosPath = Path.Combine(Config.LibraryConfiguration.LibraryFirmwareDirectory, emulatorBiosItem.hash + ".bios");
-
-                            if (File.Exists(oldBiosPath))
-                            {
-                                File.Copy(oldBiosPath, newBiosPath, true);
-                            }
-                        }
-                    }
-                }
-
-                // remove old BIOS folder structure
-                Directory.Delete(Config.LibraryConfiguration.LibraryBIOSDirectory, true);
-            }
-        }
-
         public static Models.PlatformMapping.PlatformMapItem? BiosHashSignatureLookup(string MD5)
         {
             foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
@@ -123,11 +97,10 @@ namespace gaseous_server.Classes
             {
                 get
                 {
-                    return Path.Combine(Config.LibraryConfiguration.LibraryFirmwareDirectory, hash + ".bios");
+                    return Path.Combine(Config.LibraryConfiguration.LibraryBIOSDirectory, platformslug, base.filename);
                 }
             }
-            public bool Available
+            public bool Available {
-            {
                 get
                 {
                     bool fileExists = File.Exists(biosPath);

gaseous-server/Classes/Collections.cs

@@ -4,29 +4,27 @@ using System.IO.Compression;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
-using Authentication;
 using gaseous_server.Classes.Metadata;
 using gaseous_server.Controllers;
-using gaseous_server.Controllers.v1_1;
 using gaseous_server.Models;
+using gaseous_tools;
 using IGDB.Models;
-using Microsoft.AspNetCore.Identity;
-using Microsoft.AspNetCore.Mvc.Filters;
 using Newtonsoft.Json;
-using SharpCompress.Common;
-using static gaseous_server.Classes.Metadata.Games;
 
 namespace gaseous_server.Classes
 {
 	public class Collections
 	{
-        public static List<CollectionItem> GetCollections(string userid) {
+		public Collections()
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+		{
-            string sql = "SELECT * FROM RomCollections WHERE OwnedBy=@ownedby ORDER BY `Name`";
+            
-            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+		}
-                { "ownedby", userid }
+
-            };
+        public static List<CollectionItem> GetCollections() {
-            DataTable data = db.ExecuteCMD(sql, dbDict);
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM RomCollections ORDER BY `Name`";
+
+            DataTable data = db.ExecuteCMD(sql);
 
             List<CollectionItem> collectionItems = new List<CollectionItem>();
 
@@ -37,24 +35,11 @@ namespace gaseous_server.Classes
             return collectionItems;
         }
 
-        public static CollectionItem GetCollection(long Id, string userid) {
+        public static CollectionItem GetCollection(long Id) {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql;
+			string sql = "SELECT * FROM RomCollections WHERE Id = @id ORDER BY `Name`";
-            if (userid == "")
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            {
+			dbDict.Add("id", Id);
-                // reserved for internal operations
-                sql = "SELECT * FROM RomCollections WHERE Id = @id ORDER BY `Name`";
-            }
-            else
-            {
-                // instigated by a user
-                sql = "SELECT * FROM RomCollections WHERE Id = @id AND OwnedBy = @ownedby ORDER BY `Name`";
-            }
-			Dictionary<string, object> dbDict = new Dictionary<string, object>
-            {
-                { "id", Id },
-                { "ownedby", userid }
-            };
 			DataTable romDT = db.ExecuteCMD(sql, dbDict);
 
 			if (romDT.Rows.Count > 0)
@@ -70,68 +55,60 @@ namespace gaseous_server.Classes
 			}
         }
 
-        public static CollectionItem NewCollection(CollectionItem item, string userid)
+        public static CollectionItem NewCollection(CollectionItem item)
         {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "INSERT INTO RomCollections (`Name`, Description, Platforms, Genres, Players, PlayerPerspectives, Themes, MinimumRating, MaximumRating, MaximumRomsPerPlatform, MaximumBytesPerPlatform, MaximumCollectionSizeInBytes, FolderStructure, IncludeBIOSFiles, ArchiveType, AlwaysInclude, BuiltStatus, OwnedBy) VALUES (@name, @description, @platforms, @genres, @players, @playerperspectives, @themes, @minimumrating, @maximumrating, @maximumromsperplatform, @maximumbytesperplatform, @maximumcollectionsizeinbytes, @folderstructure, @includebiosfiles, @archivetype, @alwaysinclude, @builtstatus, @ownedby); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+            string sql = "INSERT INTO RomCollections (`Name`, Description, Platforms, Genres, Players, PlayerPerspectives, Themes, MinimumRating, MaximumRating, MaximumRomsPerPlatform, MaximumBytesPerPlatform, MaximumCollectionSizeInBytes, FolderStructure, IncludeBIOSFiles, AlwaysInclude, BuiltStatus) VALUES (@name, @description, @platforms, @genres, @players, @playerperspectives, @themes, @minimumrating, @maximumrating, @maximumromsperplatform, @maximumbytesperplatform, @maximumcollectionsizeinbytes, @folderstructure, @includebiosfiles, @alwaysinclude, @builtstatus); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            {
+            dbDict.Add("name", item.Name);
-                { "name", item.Name },
+            dbDict.Add("description", item.Description);
-                { "description", item.Description },
+            dbDict.Add("platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())));
-                { "platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())) },
+            dbDict.Add("genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())));
-                { "genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())) },
+            dbDict.Add("players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())));
-                { "players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())) },
+            dbDict.Add("playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())));
-                { "playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())) },
+            dbDict.Add("themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())));
-                { "themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())) },
+            dbDict.Add("minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1));
-                { "minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1) },
+            dbDict.Add("maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1));
-                { "maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1) },
+            dbDict.Add("maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1));
-                { "maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1) },
+            dbDict.Add("maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1));
-                { "maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1) },
+            dbDict.Add("maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1));
-                { "maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1) },
+            dbDict.Add("folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous));
-                { "folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous) },
+            dbDict.Add("includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0));
-                { "includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0) },
+            dbDict.Add("alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())));
-                { "archivetype", Common.ReturnValueIfNull(item.ArchiveType, CollectionItem.ArchiveTypes.Zip) },
+            dbDict.Add("builtstatus", CollectionItem.CollectionBuildStatus.WaitingForBuild);
-                { "alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())) },
-                { "builtstatus", CollectionItem.CollectionBuildStatus.WaitingForBuild },
-                { "ownedby", userid }
-            };
             DataTable romDT = db.ExecuteCMD(sql, dbDict);
             long CollectionId = (long)romDT.Rows[0][0];
 
-            CollectionItem collectionItem = GetCollection(CollectionId, userid);
+            CollectionItem collectionItem = GetCollection(CollectionId);
 
-            StartCollectionItemBuild(CollectionId, userid);
+            StartCollectionItemBuild(CollectionId);
 
             return collectionItem;
         }
 
-        public static CollectionItem EditCollection(long Id, CollectionItem item, string userid, bool ForceRebuild = true)
+        public static CollectionItem EditCollection(long Id, CollectionItem item, bool ForceRebuild = true)
         {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "UPDATE RomCollections SET `Name`=@name, Description=@description, Platforms=@platforms, Genres=@genres, Players=@players, PlayerPerspectives=@playerperspectives, Themes=@themes, MinimumRating=@minimumrating, MaximumRating=@maximumrating, MaximumRomsPerPlatform=@maximumromsperplatform, MaximumBytesPerPlatform=@maximumbytesperplatform, MaximumCollectionSizeInBytes=@maximumcollectionsizeinbytes, FolderStructure=@folderstructure, IncludeBIOSFiles=@includebiosfiles, ArchiveType=@archivetype, AlwaysInclude=@alwaysinclude, BuiltStatus=@builtstatus WHERE Id=@id AND OwnedBy=@ownedby";
+            string sql = "UPDATE RomCollections SET `Name`=@name, Description=@description, Platforms=@platforms, Genres=@genres, Players=@players, PlayerPerspectives=@playerperspectives, Themes=@themes, MinimumRating=@minimumrating, MaximumRating=@maximumrating, MaximumRomsPerPlatform=@maximumromsperplatform, MaximumBytesPerPlatform=@maximumbytesperplatform, MaximumCollectionSizeInBytes=@maximumcollectionsizeinbytes, FolderStructure=@folderstructure, IncludeBIOSFiles=@includebiosfiles, AlwaysInclude=@alwaysinclude, BuiltStatus=@builtstatus WHERE Id=@id";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            {
+            dbDict.Add("id", Id);
-                { "id", Id },
+            dbDict.Add("name", item.Name);
-                { "name", item.Name },
+            dbDict.Add("description", item.Description);
-                { "description", item.Description },
+            dbDict.Add("platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())));
-                { "platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())) },
+            dbDict.Add("genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())));
-                { "genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())) },
+            dbDict.Add("players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())));
-                { "players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())) },
+            dbDict.Add("playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())));
-                { "playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())) },
+            dbDict.Add("themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())));
-                { "themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())) },
+            dbDict.Add("minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1));
-                { "minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1) },
+            dbDict.Add("maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1));
-                { "maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1) },
+            dbDict.Add("maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1));
-                { "maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1) },
+            dbDict.Add("maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1));
-                { "maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1) },
+            dbDict.Add("maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1));
-                { "maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1) },
+            dbDict.Add("folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous));
-                { "folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous) },
+            dbDict.Add("includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0));
-                { "includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0) },
+            dbDict.Add("alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())));
-                { "alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())) },
-                { "archivetype", Common.ReturnValueIfNull(item.ArchiveType, CollectionItem.ArchiveTypes.Zip) },
-                { "ownedby", userid }
-            };
             
-            string CollectionZipFile = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + item.ArchiveExtension);
+            string CollectionZipFile = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + ".zip");
             if (ForceRebuild == true) 
             {
                 dbDict.Add("builtstatus", CollectionItem.CollectionBuildStatus.WaitingForBuild);
@@ -154,25 +131,22 @@ namespace gaseous_server.Classes
             }
             db.ExecuteCMD(sql, dbDict);
             
-            CollectionItem collectionItem = GetCollection(Id, userid);
+            CollectionItem collectionItem = GetCollection(Id);
 
             if (collectionItem.BuildStatus == CollectionItem.CollectionBuildStatus.WaitingForBuild)
             {
-                StartCollectionItemBuild(Id, userid);
+                StartCollectionItemBuild(Id);
             }
 
             return collectionItem;
         }
 
-        public static void DeleteCollection(long Id, string userid)
+        public static void DeleteCollection(long Id)
         {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "DELETE FROM RomCollections WHERE Id=@id AND OwnedBy=@ownedby";
+            string sql = "DELETE FROM RomCollections WHERE Id=@id";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            {
+            dbDict.Add("id", Id);
-                { "id", Id },
-                { "ownedby", userid }
-            };
             db.ExecuteCMD(sql, dbDict);
 
             string CollectionZipFile = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + ".zip");
@@ -182,15 +156,14 @@ namespace gaseous_server.Classes
             }
         }
 
-        public static void StartCollectionItemBuild(long Id, string userid)
+        public static void StartCollectionItemBuild(long Id)
         {
-            // send blank user id to getcollection as this is not a user initiated process
+            CollectionItem collectionItem = GetCollection(Id);
-            CollectionItem collectionItem = GetCollection(Id, userid);
 
             if (collectionItem.BuildStatus != CollectionItem.CollectionBuildStatus.Building)
             {
                 // set collection item to waitingforbuild
-                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
                 string sql = "UPDATE RomCollections SET BuiltStatus=@bs WHERE Id=@id";
                 Dictionary<string, object> dbDict = new Dictionary<string, object>();
                 dbDict.Add("id", Id);
@@ -199,40 +172,13 @@ namespace gaseous_server.Classes
 
                 // start background task
                 ProcessQueue.QueueItem queueItem = new ProcessQueue.QueueItem(ProcessQueue.QueueItemType.CollectionCompiler, 1, false, true);
-                queueItem.Options = new Dictionary<string, object>{
+                queueItem.Options = Id;
-                    { "Id", Id },
-                    { "UserId", userid }
-                };
                 queueItem.ForceExecute();
                 ProcessQueue.QueueItems.Add(queueItem);
             }
         }
 
-        public static CollectionContents GetCollectionContent(CollectionItem collectionItem, string userid) {
+        public static CollectionContents GetCollectionContent(CollectionItem collectionItem) {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-            // get age ratings for specified user
-            List<AgeGroups.AgeRestrictionGroupings> UserAgeGroupings = new List<AgeGroups.AgeRestrictionGroupings>();
-            bool UserAgeGroupIncludeUnrated = true;
-            if (userid != "")
-            {
-                Authentication.UserTable<Authentication.ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
-                var user = userTable.GetUserById(userid);
-
-                if (user.SecurityProfile.AgeRestrictionPolicy.IncludeUnrated == false)
-                {
-                    UserAgeGroupIncludeUnrated = false;
-                }
-
-                foreach (AgeGroups.AgeRestrictionGroupings ageGrouping in Enum.GetValues(typeof(AgeGroups.AgeRestrictionGroupings)))
-                {
-                    if (ageGrouping <= user.SecurityProfile.AgeRestrictionPolicy.MaximumAgeRestriction && ageGrouping != AgeGroups.AgeRestrictionGroupings.Unclassified)
-                    {
-                        UserAgeGroupings.Add(ageGrouping);
-                    }
-                }
-            }
-
             List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = new List<CollectionContents.CollectionPlatformItem>();
 
             // get platforms
@@ -266,16 +212,9 @@ namespace gaseous_server.Classes
                 }
             } else {
                 // get all platforms to pull from
-                Dictionary<string, List<Filters.FilterItem>> FilterDict = Filters.Filter(AgeGroups.AgeRestrictionGroupings.Adult, true);
+                FilterController filterController = new FilterController();
-                List<Classes.Filters.FilterItem> filteredPlatforms = (List<Classes.Filters.FilterItem>)FilterDict["platforms"];
+                platforms.AddRange((List<Platform>)filterController.Filter()["platforms"]);
-                foreach (Filters.FilterItem filterItem in filteredPlatforms) {
-                    platforms.Add(Platforms.GetPlatform(filterItem.Id));
             }
-            }
-
-            // age ratings
-            AgeGroups.AgeRestrictionGroupings AgeGrouping = AgeGroups.AgeRestrictionGroupings.Unclassified;
-            bool ContainsUnclassifiedAgeGroup = false;
 
             // build collection
             List<CollectionContents.CollectionPlatformItem> platformItems = new List<CollectionContents.CollectionPlatformItem>();
@@ -294,29 +233,18 @@ namespace gaseous_server.Classes
                     isDynamic = true;
                 }
 
-                Controllers.v1_1.GamesController.GameReturnPackage games = new Controllers.v1_1.GamesController.GameReturnPackage();
+                List<Game> games = new List<Game>();
                 if (isDynamic == true)
                 {
-                    Controllers.v1_1.GamesController.GameSearchModel searchModel = new Controllers.v1_1.GamesController.GameSearchModel{
+                    games = GamesController.GetGames("",
-                        Name = "",
+                        platform.Id.ToString(),
-                        Platform = new List<string>{
+                        string.Join(",", collectionItem.Genres),
-                            platform.Id.ToString()
+                        string.Join(",", collectionItem.Players),
-                        },
+                        string.Join(",", collectionItem.PlayerPerspectives),
-                        Genre = collectionItem.Genres.ConvertAll(s => s.ToString()),
+                        string.Join(",", collectionItem.Themes),
-                        GameMode = collectionItem.Players.ConvertAll(s => s.ToString()),
+                        collectionItem.MinimumRating,
-                        PlayerPerspective = collectionItem.PlayerPerspectives.ConvertAll(s => s.ToString()),
+                        collectionItem.MaximumRating
-                        Theme = collectionItem.Themes.ConvertAll(s => s.ToString()),
+                    );
-                        GameRating = new Controllers.v1_1.GamesController.GameSearchModel.GameRatingItem{
-                            MinimumRating = collectionItem.MinimumRating,
-                            MaximumRating = collectionItem.MaximumRating
-                        },
-                        GameAgeRating = new Controllers.v1_1.GamesController.GameSearchModel.GameAgeRatingItem{
-                            AgeGroupings = UserAgeGroupings,
-                            IncludeUnrated = UserAgeGroupIncludeUnrated
-                        }
-                    };
-                    games = Controllers.v1_1.GamesController.GetGames(searchModel, userid);
-                    
                 }
 
                 CollectionContents.CollectionPlatformItem collectionPlatformItem = new CollectionContents.CollectionPlatformItem(platform);
@@ -332,19 +260,19 @@ namespace gaseous_server.Classes
                         ) && alwaysIncludeItem.PlatformId == platform.Id
                         ) 
                         {
-                            MinimalGameItem AlwaysIncludeGame = new MinimalGameItem(Games.GetGame(alwaysIncludeItem.GameId, false, false, false));
+                            Game AlwaysIncludeGame = Games.GetGame(alwaysIncludeItem.GameId, false, false, false);
                             CollectionContents.CollectionPlatformItem.CollectionGameItem gameItem = new CollectionContents.CollectionPlatformItem.CollectionGameItem(AlwaysIncludeGame);
                             gameItem.InclusionStatus = new CollectionItem.AlwaysIncludeItem();
                             gameItem.InclusionStatus.PlatformId = alwaysIncludeItem.PlatformId;
                             gameItem.InclusionStatus.GameId = alwaysIncludeItem.GameId;
                             gameItem.InclusionStatus.InclusionState = alwaysIncludeItem.InclusionState;
-                            gameItem.Roms = Roms.GetRoms((long)gameItem.Id, (long)platform.Id).GameRomItems;
+                            gameItem.Roms = Roms.GetRoms((long)gameItem.Id, (long)platform.Id);
 
                             collectionPlatformItem.Games.Add(gameItem);
                     }
                 }
 
-                foreach (MinimalGameItem game in games.Games) {
+                foreach (Game game in games) {
                     bool gameAlreadyInList = false;
                     foreach (CollectionContents.CollectionPlatformItem.CollectionGameItem existingGame in collectionPlatformItem.Games) 
                     {
@@ -358,14 +286,14 @@ namespace gaseous_server.Classes
                     {
                         CollectionContents.CollectionPlatformItem.CollectionGameItem collectionGameItem = new CollectionContents.CollectionPlatformItem.CollectionGameItem(game);
 
-                        List<Roms.GameRomItem> gameRoms = Roms.GetRoms((long)game.Id, (long)platform.Id).GameRomItems;
+                        List<Roms.GameRomItem> gameRoms = Roms.GetRoms((long)game.Id, (long)platform.Id);
                         
                         bool AddGame = false;
 
                         // calculate total rom size for the game
                         long GameRomSize = 0;
                         foreach (Roms.GameRomItem gameRom in gameRoms) {
-                            GameRomSize += (long)gameRom.Size;
+                            GameRomSize += gameRom.Size;
                         }
                         if (collectionItem.MaximumBytesPerPlatform > 0) {
                             if ((TotalRomSize + GameRomSize) < collectionItem.MaximumBytesPerPlatform) {
@@ -399,17 +327,6 @@ namespace gaseous_server.Classes
                             }
                         }
                     }
-
-                    // handle age grouping
-                    AgeGroups.AgeRestrictionGroupings CurrentAgeGroup = AgeGroups.GetAgeGroupFromAgeRatings(game.AgeRatings);
-                    if (CurrentAgeGroup > AgeGrouping)
-                    {
-                        AgeGrouping = CurrentAgeGroup;
-                    }
-                    if (CurrentAgeGroup == AgeGroups.AgeRestrictionGroupings.Unclassified)
-                    {
-                        ContainsUnclassifiedAgeGroup = true;
-                    }
                 }
 
                 collectionPlatformItem.Games.Sort((x, y) => x.Name.CompareTo(y.Name));
@@ -438,40 +355,30 @@ namespace gaseous_server.Classes
 
             collectionPlatformItems.Sort((x, y) => x.Name.CompareTo(y.Name));
 
-            CollectionContents collectionContents = new CollectionContents
+            CollectionContents collectionContents = new CollectionContents();
-            {
+            collectionContents.Collection = collectionPlatformItems;
-                Collection = collectionPlatformItems,
-                AgeGroup = AgeGrouping,
-                ContainsUnclassifiedAgeGroup = ContainsUnclassifiedAgeGroup
-            };
 
             return collectionContents;
         }
 
-        public static void CompileCollections(long CollectionId, string userid)
+        public static void CompileCollections(long CollectionId)
         {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
-            CollectionItem collectionItem = GetCollection(CollectionId, userid);
+            CollectionItem collectionItem = GetCollection(CollectionId);
             if (collectionItem.BuildStatus == CollectionItem.CollectionBuildStatus.WaitingForBuild)
             {
                 Logging.Log(Logging.LogType.Information, "Collections", "Beginning build of collection: " + collectionItem.Name);
 
-                CollectionContents collectionContents = GetCollectionContent(collectionItem, userid);
-
                 // set starting
-                string sql = "UPDATE RomCollections SET BuiltStatus=@bs, AgeGroup=@ag, AgeGroupUnclassified=@agu WHERE Id=@id";
+                string sql = "UPDATE RomCollections SET BuiltStatus=@bs WHERE Id=@id";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>
+                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                {
+                dbDict.Add("id", collectionItem.Id);
-                    { "id", collectionItem.Id },
+                dbDict.Add("bs", CollectionItem.CollectionBuildStatus.Building);
-                    { "bs", CollectionItem.CollectionBuildStatus.Building },
-                    { "ag", collectionContents.AgeGroup },
-                    { "agu", collectionContents.ContainsUnclassifiedAgeGroup }
-                };
                 db.ExecuteCMD(sql, dbDict);
 
-                List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = collectionContents.Collection;
+                List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = GetCollectionContent(collectionItem).Collection;
-                string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, collectionItem.Id + collectionItem.ArchiveExtension);
+                string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, collectionItem.Id + ".zip");
                 string ZipFileTempPath = Path.Combine(Config.LibraryConfiguration.LibraryTempDirectory, collectionItem.Id.ToString());
 
                 try
@@ -509,7 +416,7 @@ namespace gaseous_server.Classes
                                 if (File.Exists(biosItem.biosPath))
                                 {
                                     Logging.Log(Logging.LogType.Information, "Collections", "Copying BIOS file: " + biosItem.filename);
-                                    File.Copy(biosItem.biosPath, Path.Combine(ZipBiosPath, biosItem.filename), true);
+                                    File.Copy(biosItem.biosPath, Path.Combine(ZipBiosPath, biosItem.filename));
                                 }
                             }
                         }
@@ -581,7 +488,7 @@ namespace gaseous_server.Classes
                                     if (File.Exists(gameRomItem.Path))
                                     {
                                         Logging.Log(Logging.LogType.Information, "Collections", "Copying ROM: " + gameRomItem.Name);
-                                        File.Copy(gameRomItem.Path, Path.Combine(ZipGamePath, gameRomItem.Name), true);
+                                        File.Copy(gameRomItem.Path, Path.Combine(ZipGamePath, gameRomItem.Name));
                                     }
                                 }
                             }
@@ -590,21 +497,7 @@ namespace gaseous_server.Classes
 
                     // compress to zip
                     Logging.Log(Logging.LogType.Information, "Collections", "Compressing collection");
-                    switch(collectionItem.ArchiveType)
-                    {
-                        case CollectionItem.ArchiveTypes.Zip:
                     ZipFile.CreateFromDirectory(ZipFileTempPath, ZipFilePath, CompressionLevel.SmallestSize, false);
-                            break;
-
-                        case CollectionItem.ArchiveTypes.RAR:
-
-                            break;
-
-                        case CollectionItem.ArchiveTypes.SevenZip:
-                            
-                            break;
-                    }
-                    
 
                     // clean up
                     if (Directory.Exists(ZipFileTempPath))
@@ -663,7 +556,6 @@ namespace gaseous_server.Classes
             item.MaximumCollectionSizeInBytes = (long)Common.ReturnValueIfNull(row["MaximumCollectionSizeInBytes"], (long)-1);
             item.FolderStructure = (CollectionItem.FolderStructures)(int)Common.ReturnValueIfNull(row["FolderStructure"], 0);
             item.IncludeBIOSFiles = (bool)row["IncludeBIOSFiles"];
-            item.ArchiveType = (CollectionItem.ArchiveTypes)(int)Common.ReturnValueIfNull(row["ArchiveType"], 0);
             item.AlwaysInclude = Newtonsoft.Json.JsonConvert.DeserializeObject<List<CollectionItem.AlwaysIncludeItem>>(strAlwaysInclude);
             item.BuildStatus = (CollectionItem.CollectionBuildStatus)(int)Common.ReturnValueIfNull(row["BuiltStatus"], 0);
 
@@ -692,32 +584,6 @@ namespace gaseous_server.Classes
             public long? MaximumCollectionSizeInBytes { get; set; }
             public FolderStructures FolderStructure { get; set; } = FolderStructures.Gaseous;
             public bool IncludeBIOSFiles { get; set; } = true;
-            public ArchiveTypes ArchiveType { get; set; } = CollectionItem.ArchiveTypes.Zip;
-            public string ArchiveExtension
-            {
-                get
-                {
-                    if (ArchiveType != null)
-                    {
-                        switch (ArchiveType)
-                        {
-                            case ArchiveTypes.Zip:
-                            default:
-                                return ".zip";
-                            
-                            case ArchiveTypes.RAR:
-                                return ".rar";
-
-                            case ArchiveTypes.SevenZip:
-                                return ".7z";
-                        }
-                    }
-                    else
-                    {
-                        return ".zip";
-                    }
-                }
-            }
             public List<AlwaysIncludeItem> AlwaysInclude { get; set; }
 
             [JsonIgnore]
@@ -727,7 +593,7 @@ namespace gaseous_server.Classes
                 {
                     if (_BuildStatus == CollectionBuildStatus.Completed)
                     {
-                        if (File.Exists(Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + ArchiveExtension)))
+                        if (File.Exists(Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + ".zip")))
                         {
                             return CollectionBuildStatus.Completed;
                         }
@@ -755,7 +621,7 @@ namespace gaseous_server.Classes
                 {
                     if (BuildStatus == CollectionBuildStatus.Completed)
                     {
-                        string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + ArchiveExtension);
+                        string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + ".zip");
                         if (File.Exists(ZipFilePath))
                         {
                             FileInfo fi = new FileInfo(ZipFilePath);
@@ -788,13 +654,6 @@ namespace gaseous_server.Classes
                 RetroPie = 1
             }
 
-            public enum ArchiveTypes
-            {
-                Zip = 0,
-                RAR = 1,
-                SevenZip = 2
-            }
-
             public class AlwaysIncludeItem
             {
                 public long PlatformId { get; set; }
@@ -837,9 +696,6 @@ namespace gaseous_server.Classes
                 }
             }
 
-            public AgeGroups.AgeRestrictionGroupings AgeGroup { get; set; }
-            public bool ContainsUnclassifiedAgeGroup { get; set; }
-
             public class CollectionPlatformItem {
                 public CollectionPlatformItem(IGDB.Models.Platform platform) {
                     string[] PropertyWhitelist = new string[] { "Id", "Name", "Slug" };
@@ -882,7 +738,7 @@ namespace gaseous_server.Classes
                         long Size = 0;
                         foreach (CollectionGameItem Game in Games) {
                             foreach (Roms.GameRomItem Rom in Game.Roms) {
-                                Size += (long)Rom.Size;
+                                Size += Rom.Size;
                             }
                         }
 
@@ -890,45 +746,41 @@ namespace gaseous_server.Classes
                     }
                 }
 
-                public class CollectionGameItem : MinimalGameItem
+                public class CollectionGameItem {
+                    public CollectionGameItem(IGDB.Models.Game game) {
+                        string[] PropertyWhitelist = new string[] { "Id", "Name", "Slug", "Cover" };
+                        PropertyInfo[] srcProperties = typeof(IGDB.Models.Game).GetProperties();
+                        PropertyInfo[] dstProperties = typeof(CollectionPlatformItem.CollectionGameItem).GetProperties();
+                        foreach (PropertyInfo srcProperty in srcProperties) {
+                            if (PropertyWhitelist.Contains<string>(srcProperty.Name))
                             {
-                    public CollectionGameItem(MinimalGameItem gameObject)
+                                foreach (PropertyInfo dstProperty in dstProperties)
                                 {
-                        this.Id = gameObject.Id;
+                                    if (srcProperty.Name == dstProperty.Name)
-                        this.Name = gameObject.Name;
+                                    {
-                        this.Slug = gameObject.Slug;
+                                        if (srcProperty.GetValue(game) != null) {
-                        this.TotalRating = gameObject.TotalRating;
+                                            string compareName = srcProperty.PropertyType.Name.ToLower().Split("`")[0];
-                        this.TotalRatingCount = gameObject.TotalRatingCount;
+                                            switch(compareName) {
-                        this.Cover = gameObject.Cover;
+                                                case "identityorvalue":
-                        this.Artworks = gameObject.Artworks;
+                                                    string newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(srcProperty.GetValue(game));
-                        this.FirstReleaseDate = gameObject.FirstReleaseDate;
+                                                    Dictionary<string, object> newDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(newObjectValue);
-                        this.AgeRatings = gameObject.AgeRatings;
+                                                    dstProperty.SetValue(this, newDict["Id"]);
+                                                    break;
+                                                default:
+                                                    dstProperty.SetValue(this, srcProperty.GetValue(game));
+                                                    break;
+                                            }
+                                        }
                                     }
-                    
-                    public IGDB.Models.Cover? CoverItem
-                    {
-                        get
-                        {
-                            if (Cover != null)
-                            {
-                                IGDB.Models.Cover cover = Covers.GetCover(Cover.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory, "Games", Slug), false);
-
-                                return cover;
                                 }
-                            else
-                            {
-                                return null;
                             }
                         }
                     }
 
-                    public AgeGroups.AgeRestrictionGroupings AgeGrouping
+                    public long Id { get; set; }
-                    { 
+                    public string Name { get; set; }
-                        get
+                    public string Slug { get; set; }
-                        {
+                    public long Cover { get; set;}
-                            return AgeGroups.GetAgeGroupFromAgeRatings(this.AgeRatings);
-                        }
-                    }
 
                     public CollectionItem.AlwaysIncludeItem InclusionStatus { get; set; }
 
@@ -938,7 +790,7 @@ namespace gaseous_server.Classes
                     get {
                         long Size = 0;
                         foreach (Roms.GameRomItem Rom in Roms) {
-                            Size += (long)Rom.Size;
+                            Size += Rom.Size;
                         }
                     
                         return Size;