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/.env

@@ -1,4 +0,0 @@
-DATABASE_HOST=mariadb
-DATABASE_USER=root
-DATABASE_PASSWORD=gaseous
-DATABASE_DB=gaseous

.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.11.7z
-RUN 7z x -y -o/workspace/gaseous-server/wwwroot/emulators/EmulatorJS 4.0.11.7z

.devcontainer/devcontainer.json

@@ -1,46 +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"
-			]
-		}
-	}
-
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
-}

.devcontainer/docker-compose.yml

@@ -1,23 +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=<clientid>
-      - igdbclientsecret=<clientsecret>
-  mariadb:
-    hostname: mariadb
-    image: mariadb:latest
-    environment:
-      - MARIADB_ROOT_PASSWORD=${DATABASE_PASSWORD}
-      - MARIADB_DATABASE=${DATABASE_DB}
-      - MARIADB_USER=${DATABASE_USER}
-      - MARIADB_PASSWORD=${DATABASE_PASSWORD}

.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"
+      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
-        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
+      - name: Build and push
+        uses: docker/build-push-action@v4
         with:
           context: .
-          file: ./build/Dockerfile
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64 #,linux/arm64
           push: true
-          tags: |
-            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
+          tags: gaseousgames/gaseousserver:${{ github.ref_name}}

.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,41 +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
-        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
+      - name: Build and push
+        uses: docker/build-push-action@v4
         with:
           context: .
-          file: ./build/Dockerfile
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64 #,linux/arm64
           push: true
-          tags: |
-            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:latest-embeddeddb
-            gaseousgames/gaseousserver:${{ github.ref_name}}-embeddeddb
-            ghcr.io/gaseous-project/gaseousserver:latest-embeddeddb
-            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}-embeddeddb
+          tags: gaseousgames/gaseousserver:latest,gaseousgames/gaseousserver:${{ github.ref_name}}

.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/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,5 +403,3 @@ ASALocalRun/
 
 # Local History for Visual Studio
 .localhistory/
-gaseous-server/.DS_Store
-gaseous-server/wwwroot/emulators/EmulatorJS

.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
@@ -27,18 +29,34 @@ Global
 		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
+		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Release|Any CPU.ActiveCfg = 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
-                       Version 3, 19 November 2007
+                    GNU GENERAL PUBLIC LICENSE
+                       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
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
 
   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
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
 
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-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.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
 
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-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.
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
 
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+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.
-
-  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.
+  13. Use with the GNU Affero General Public License.
 
   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
-3 of the GNU General Public License.
+but the special requirements of the GNU Affero 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
-will be similar in spirit to the present version, but may differ in detail to
+the GNU General Public License from time to time.  Such new versions will
+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.>
-    Copyright (C) <year>  <name of author>
+    Gaseous
+    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
-    by the Free Software Foundation, either version 3 of the License, or
+    it under the terms of the GNU General Public License as published by
+    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
-network, you should also make sure that it provides a way for users to
-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
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) 2023  Gaseous
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    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
-<https://www.gnu.org/licenses/>.
+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,53 +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) [![CodeQL](https://github.com/gaseous-project/gaseous-server/actions/workflows/codeql.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/codeql.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
 
-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.
 
 ## Warning
 
-Versions 1.6.1 and earlier are not suitable for being exposed to the internet, as:
-1. there is no authentication support, meaning anyone could trash your library
+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 one of these earlier versions of the server to the internet, **you do so at your own risk**.
-
-Version 1.7.0 and later contain user authentication, and can be exposed to the internet. However, it is recommended to no 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.
-
-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**.
+If you expose the server to the internet, **you do so at your own risk**.
 
 ## Screenshots
 ![Library](./screenshots/Library.png)
 ![Game](./screenshots/Game.png)
 ![Emulator](./screenshots/Emulator.png)
 
-
 ## Requirements
-* MariaDB 11.1.2 (preferred) or 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.
+* MySQL Server 8+*
 * Internet Game Database API Key. See: https://api-docs.igdb.com/#account-creation
 
-If using the provided docker-compose.yml, MariaDB will be installed for you.
-
-## 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
+***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
 
 ## Third Party Projects
 The following projects are used by Gaseous
-* [ASP.NET](https://dotnet.microsoft.com/en-us/apps/aspnet)
-* [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json)
-* [MySQLConnector](https://mysqlconnector.net)
-* [IGDB-DOTNET](https://github.com/kamranayub/igdb-dotnet)
-* [EmulatorJS](https://github.com/EmulatorJS/EmulatorJS)
+* https://dotnet.microsoft.com/en-us/apps/aspnet
+* https://github.com/JamesNK/Newtonsoft.Json
+* https://www.nuget.org/packages/MySql.Data/8.0.32.1
+* https://github.com/kamranayub/igdb-dotnet
+* https://github.com/EmulatorJS/EmulatorJS
 
 ## Discord Server
 [![Join our Discord server!](https://invite.casperiv.dev/?inviteCode=Nhu7wpT3k4&format=svg)](https://discord.gg/Nhu7wpT3k4)
 
-# Installation
-See https://github.com/gaseous-project/gaseous-server/wiki/Installation for installation instructions.
+# 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
-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
+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,41 +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 .. ./
-# 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
-
-# disabled for 1.7.4 as the next version EmulatorJS is not yet available
-# # 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
-RUN wget --recursive --no-parent https://cdn.emulatorjs.org/latest/
-RUN mkdir -p out/wwwroot/emulators/EmulatorJS
-RUN cp -fr cdn.emulatorjs.org/latest/* out/wwwroot/emulators/EmulatorJS
-RUN rm -Rf cdn.emulatorjs.org
-
-# 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 .
-
-# start gaseous-server
-ENTRYPOINT ["dotnet", "gaseous-server.dll"]

build/Dockerfile-EmbeddedDB

@@ -1,77 +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 .. ./
-# 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
-
-# disabled for 1.7.4 as the next version EmulatorJS is not yet available
-# # 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
-
-RUN wget --recursive --no-parent https://cdn.emulatorjs.org/latest/
-RUN mkdir -p out/wwwroot/emulators/EmulatorJS
-RUN cp -fr cdn.emulatorjs.org/latest/* out/wwwroot/emulators/EmulatorJS
-RUN rm -Rf cdn.emulatorjs.org
-
-# 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/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/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/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/entrypoint.sh

@@ -1,12 +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 -G sudo 
-usermod -p "*" gaseous
-mkdir -p /home/gaseous/.gaseous-server /var/lib/mysql
-chown -R ${PUID}:${PGID} /App /home/gaseous/.gaseous-server /var/lib/mysql /run/mysqld
-
-# Start supervisord and services
-/usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf

build/mariadb.sh

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

build/supervisord.conf

@@ -1,35 +0,0 @@
-[supervisord]
-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
-autostart=true
-autorestart=true
-redirect_stderr=true
-stdout_logfile=/dev/fd/1
-stdout_logfile_maxbytes=0

docker-compose-build.yml

@@ -14,7 +14,6 @@ services:
     volumes:
       - gs:/root/.gaseous-server
     environment:
-      - TZ=Australia/Sydney
       - dbhost=gsdb
       - dbuser=root
       - dbpass=gaseous
@@ -22,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
-      - MARIADB_USER=gaseous
-      - MARIADB_PASSWORD=gaseous
+      - MYSQL_ROOT_PASSWORD=gaseous
+      - MYSQL_USER=gaseous
+      - MYSQL_PASSWORD=gaseous
 networks:
   gaseous:
     driver: bridge

docker-compose.yml

@@ -13,7 +13,6 @@ services:
     volumes:
       - gs:/root/.gaseous-server
     environment:
-      - TZ=Australia/Sydney
       - dbhost=gsdb
       - dbuser=root
       - dbpass=gaseous
@@ -21,16 +20,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
-      - MARIADB_USER=gaseous
-      - MARIADB_PASSWORD=gaseous
+      - MYSQL_ROOT_PASSWORD=gaseous
+      - MYSQL_USER=gaseous
+      - MYSQL_PASSWORD=gaseous
 networks:
   gaseous:
     driver: bridge

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 Avatar { 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,469 +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 UserId, Id AS AvatarId FROM UserAvatars) UserAvatars ON Users.Id = UserAvatars.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.Avatar = string.IsNullOrEmpty((string?)row["AvatarId"]) ? Guid.Empty : Guid.Parse((string?)row["AvatarId"]);
-            }
-
-            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 UserId, Id AS AvatarId FROM UserAvatars) UserAvatars ON Users.Id = UserAvatars.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.Avatar = string.IsNullOrEmpty((string?)row["AvatarId"]) ? Guid.Empty : Guid.Parse((string?)row["AvatarId"]);
-                users.Add(user);
-            }
-
-            return users;
-        }
-
-        public List<TUser> GetUsers()
-        {
-            List<TUser> users = new List<TUser>();
-            string commandText = "Select * from Users LEFT JOIN (SELECT UserId, Id AS AvatarId FROM UserAvatars) UserAvatars ON Users.Id = UserAvatars.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.Avatar = string.IsNullOrEmpty((string?)row["AvatarId"]) ? Guid.Empty : Guid.Parse((string?)row["AvatarId"]);
-                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);";
-            Dictionary<string, object> parameters = new Dictionary<string, object>();
-            parameters.Add("@name", user.UserName);
-            parameters.Add("@id", user.Id);
-            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 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,48 +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 Avatar { 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,48 +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 Avatar { 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/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
 {

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) {
-            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 }
-            };
-            DataTable data = db.ExecuteCMD(sql, dbDict);
+		public Collections()
+		{
+            
+		}
+
+        public static List<CollectionItem> GetCollections() {
+            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) {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql;
-            if (userid == "")
-            {
-                // 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 }
-            };
+        public static CollectionItem GetCollection(long Id) {
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT * FROM RomCollections WHERE Id = @id ORDER BY `Name`";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			dbDict.Add("id", Id);
 			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);
-            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);";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>
-            {
-                { "name", item.Name },
-                { "description", item.Description },
-                { "platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())) },
-                { "genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())) },
-                { "players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())) },
-                { "playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())) },
-                { "themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())) },
-                { "minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1) },
-                { "maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1) },
-                { "maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1) },
-                { "maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1) },
-                { "maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1) },
-                { "folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous) },
-                { "includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0) },
-                { "archivetype", Common.ReturnValueIfNull(item.ArchiveType, CollectionItem.ArchiveTypes.Zip) },
-                { "alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())) },
-                { "builtstatus", CollectionItem.CollectionBuildStatus.WaitingForBuild },
-                { "ownedby", userid }
-            };
+            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, 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>();
+            dbDict.Add("name", item.Name);
+            dbDict.Add("description", item.Description);
+            dbDict.Add("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>())));
+            dbDict.Add("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>())));
+            dbDict.Add("themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())));
+            dbDict.Add("minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1));
+            dbDict.Add("maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1));
+            dbDict.Add("maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1));
+            dbDict.Add("maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1));
+            dbDict.Add("maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1));
+            dbDict.Add("folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous));
+            dbDict.Add("includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0));
+            dbDict.Add("alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())));
+            dbDict.Add("builtstatus", CollectionItem.CollectionBuildStatus.WaitingForBuild);
             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);
-            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";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>
-            {
-                { "id", Id },
-                { "name", item.Name },
-                { "description", item.Description },
-                { "platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())) },
-                { "genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())) },
-                { "players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())) },
-                { "playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())) },
-                { "themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())) },
-                { "minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1) },
-                { "maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1) },
-                { "maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1) },
-                { "maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1) },
-                { "maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1) },
-                { "folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous) },
-                { "includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0) },
-                { "alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())) },
-                { "archivetype", Common.ReturnValueIfNull(item.ArchiveType, CollectionItem.ArchiveTypes.Zip) },
-                { "ownedby", userid }
-            };
+            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, AlwaysInclude=@alwaysinclude, BuiltStatus=@builtstatus WHERE Id=@id";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("id", Id);
+            dbDict.Add("name", item.Name);
+            dbDict.Add("description", item.Description);
+            dbDict.Add("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>())));
+            dbDict.Add("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>())));
+            dbDict.Add("themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())));
+            dbDict.Add("minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1));
+            dbDict.Add("maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1));
+            dbDict.Add("maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1));
+            dbDict.Add("maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1));
+            dbDict.Add("maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1));
+            dbDict.Add("folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous));
+            dbDict.Add("includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0));
+            dbDict.Add("alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())));
             
-            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);
-            string sql = "DELETE FROM RomCollections WHERE Id=@id AND OwnedBy=@ownedby";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>
-            {
-                { "id", Id },
-                { "ownedby", userid }
-            };
+            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM RomCollections WHERE Id=@id";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("id", Id);
             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, userid);
+            CollectionItem collectionItem = GetCollection(Id);
 
             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>{
-                    { "Id", Id },
-                    { "UserId", userid }
-                };
+                queueItem.Options = Id;
                 queueItem.ForceExecute();
                 ProcessQueue.QueueItems.Add(queueItem);
             }
         }
 
-        public static CollectionContents GetCollectionContent(CollectionItem collectionItem, string userid) {
-            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);
-                    }
-                }
-            }
-
+        public static CollectionContents GetCollectionContent(CollectionItem collectionItem) {
             List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = new List<CollectionContents.CollectionPlatformItem>();
 
             // get platforms
@@ -266,17 +212,10 @@ namespace gaseous_server.Classes
                 }
             } else {
                 // get all platforms to pull from
-                Dictionary<string, List<Filters.FilterItem>> FilterDict = Filters.Filter(AgeGroups.AgeRestrictionGroupings.Adult, true);
-                List<Classes.Filters.FilterItem> filteredPlatforms = (List<Classes.Filters.FilterItem>)FilterDict["platforms"];
-                foreach (Filters.FilterItem filterItem in filteredPlatforms) {
-                    platforms.Add(Platforms.GetPlatform(filterItem.Id));
-                }
+                FilterController filterController = new FilterController();
+                platforms.AddRange((List<Platform>)filterController.Filter()["platforms"]);
             }
 
-            // 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{
-                        Name = "",
-                        Platform = new List<string>{
-                            platform.Id.ToString()
-                        },
-                        Genre = collectionItem.Genres.ConvertAll(s => s.ToString()),
-                        GameMode = collectionItem.Players.ConvertAll(s => s.ToString()),
-                        PlayerPerspective = collectionItem.PlayerPerspectives.ConvertAll(s => s.ToString()),
-                        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);
-                    
+                    games = GamesController.GetGames("",
+                        platform.Id.ToString(),
+                        string.Join(",", collectionItem.Genres),
+                        string.Join(",", collectionItem.Players),
+                        string.Join(",", collectionItem.PlayerPerspectives),
+                        string.Join(",", collectionItem.Themes),
+                        collectionItem.MinimumRating,
+                        collectionItem.MaximumRating
+                    );
                 }
 
                 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
-            {
-                Collection = collectionPlatformItems,
-                AgeGroup = AgeGrouping,
-                ContainsUnclassifiedAgeGroup = ContainsUnclassifiedAgeGroup
-            };
+            CollectionContents collectionContents = new CollectionContents();
+            collectionContents.Collection = collectionPlatformItems;
 
             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";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>
-                {
-                    { "id", collectionItem.Id },
-                    { "bs", CollectionItem.CollectionBuildStatus.Building },
-                    { "ag", collectionContents.AgeGroup },
-                    { "agu", collectionContents.ContainsUnclassifiedAgeGroup }
-                };
+                string sql = "UPDATE RomCollections SET BuiltStatus=@bs WHERE Id=@id";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                dbDict.Add("id", collectionItem.Id);
+                dbDict.Add("bs", CollectionItem.CollectionBuildStatus.Building);
                 db.ExecuteCMD(sql, dbDict);
-                
-                List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = collectionContents.Collection;
-                string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, collectionItem.Id + collectionItem.ArchiveExtension);
+
+                List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = GetCollectionContent(collectionItem).Collection;
+                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;
-                    }
-                    
+                    ZipFile.CreateFromDirectory(ZipFileTempPath, ZipFilePath, CompressionLevel.SmallestSize, false);
 
                     // 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 CollectionGameItem(MinimalGameItem gameObject)
-                    {
-                        this.Id = gameObject.Id;
-                        this.Name = gameObject.Name;
-                        this.Slug = gameObject.Slug;
-                        this.TotalRating = gameObject.TotalRating;
-                        this.TotalRatingCount = gameObject.TotalRatingCount;
-                        this.Cover = gameObject.Cover;
-                        this.Artworks = gameObject.Artworks;
-                        this.FirstReleaseDate = gameObject.FirstReleaseDate;
-                        this.AgeRatings = gameObject.AgeRatings;
-                    }
-                    
-                    public IGDB.Models.Cover? CoverItem
-                    {
-                        get
-                        {
-                            if (Cover != null)
+                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))
                             {
-                                IGDB.Models.Cover cover = Covers.GetCover(Cover.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory, "Games", Slug), false);
-
-                                return cover;
-                            }
-                            else
-                            {
-                                return null;
+                                foreach (PropertyInfo dstProperty in dstProperties)
+                                {
+                                    if (srcProperty.Name == dstProperty.Name)
+                                    {
+                                        if (srcProperty.GetValue(game) != null) {
+                                            string compareName = srcProperty.PropertyType.Name.ToLower().Split("`")[0];
+                                            switch(compareName) {
+                                                case "identityorvalue":
+                                                    string newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(srcProperty.GetValue(game));
+                                                    Dictionary<string, object> newDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(newObjectValue);
+                                                    dstProperty.SetValue(this, newDict["Id"]);
+                                                    break;
+                                                default:
+                                                    dstProperty.SetValue(this, srcProperty.GetValue(game));
+                                                    break;
+                                            }
+                                        }
+                                    }
+                                }
                             }
                         }
                     }
 
-                    public AgeGroups.AgeRestrictionGroupings AgeGrouping
-                    { 
-                        get
-                        {
-                            return AgeGroups.GetAgeGroupFromAgeRatings(this.AgeRatings);
-                        }
-                    }
+                    public long Id { get; set; }
+                    public string Name { get; set; }
+                    public string Slug { get; set; }
+                    public long Cover { get; set;}
 
                     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;

gaseous-server/Classes/Common.cs

@@ -1,188 +0,0 @@
-using System.Collections.Concurrent;
-using System.ComponentModel;
-using System.Data;
-using System.IO.Compression;
-using System.Reflection;
-using System.Security.Cryptography;
-
-namespace gaseous_server.Classes
-{
-	public static class Common
-	{
-		/// <summary>
-		/// Returns IfNullValue if the ObjectToCheck is null
-		/// </summary>
-		/// <param name="ObjectToCheck">Any nullable object to check for null</param>
-		/// <param name="IfNullValue">Any object to return if ObjectToCheck is null</param>
-		/// <returns></returns>
-		static public object ReturnValueIfNull(object? ObjectToCheck, object IfNullValue)
-		{
-			if (ObjectToCheck == null || ObjectToCheck == System.DBNull.Value)
-			{
-				return IfNullValue;
-			}
-			else
-			{
-				return ObjectToCheck;
-			}
-		}
-
-		static public DateTime ConvertUnixToDateTime(double UnixTimeStamp)
-		{
-			DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
-			dateTime = dateTime.AddSeconds(UnixTimeStamp).ToLocalTime();
-			return dateTime;
-		}
-
-		public class hashObject
-		{
-			public hashObject()
-			{
-
-			}
-
-			public hashObject(string FileName)
-			{
-				var xmlStream = File.OpenRead(FileName);
-
-				Logging.Log(Logging.LogType.Information, "Hash File", "Generating MD5 hash for file: " + FileName);
-				var md5 = MD5.Create();
-				byte[] md5HashByte = md5.ComputeHash(xmlStream);
-				string md5Hash = BitConverter.ToString(md5HashByte).Replace("-", "").ToLowerInvariant();
-				_md5hash = md5Hash;
-
-				Logging.Log(Logging.LogType.Information, "Hash File", "Generating SHA1 hash for file: " + FileName);
-				var sha1 = SHA1.Create();
-				xmlStream.Position = 0;
-				byte[] sha1HashByte = sha1.ComputeHash(xmlStream);
-				string sha1Hash = BitConverter.ToString(sha1HashByte).Replace("-", "").ToLowerInvariant();
-				_sha1hash = sha1Hash;
-
-				xmlStream.Close();
-			}
-
-			string _md5hash = "";
-			string _sha1hash = "";
-
-			public string md5hash
-			{
-				get
-				{
-					return _md5hash.ToLower();
-				}
-				set
-				{
-					_md5hash = value;
-				}
-			}
-
-			public string sha1hash
-			{
-				get
-				{
-					return _sha1hash.ToLower();
-				}
-				set
-				{
-					_sha1hash = value;
-				}
-			}
-		}
-
-		public static long DirSize(DirectoryInfo d)
-		{
-			long size = 0;
-			// Add file sizes.
-			FileInfo[] fis = d.GetFiles();
-			foreach (FileInfo fi in fis)
-			{
-				size += fi.Length;
-			}
-			// Add subdirectory sizes.
-			DirectoryInfo[] dis = d.GetDirectories();
-			foreach (DirectoryInfo di in dis)
-			{
-				size += DirSize(di);
-			}
-			return size;
-		}
-
-		public static string[] SkippableFiles = {
-				".DS_STORE",
-				"desktop.ini"
-			};
-
-		public static string NormalizePath(string path)
-		{
-			return Path.GetFullPath(new Uri(path).LocalPath)
-					.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
-		}
-
-		public static string GetDescription(this Enum value)
-		{
-			return ((DescriptionAttribute)Attribute.GetCustomAttribute(
-				value.GetType().GetFields(BindingFlags.Public | BindingFlags.Static)
-					.Single(x => x.GetValue(null).Equals(value)),
-				typeof(DescriptionAttribute)))?.Description ?? value.ToString();
-		}
-
-		// compression
-		public static byte[] Compress(byte[] data)
-		{
-			MemoryStream output = new MemoryStream();
-			using (DeflateStream dstream = new DeflateStream(output, CompressionLevel.Optimal))
-			{
-				dstream.Write(data, 0, data.Length);
-			}
-			return output.ToArray();
-		}
-
-		public static byte[] Decompress(byte[] data)
-		{
-			MemoryStream input = new MemoryStream(data);
-			MemoryStream output = new MemoryStream();
-			using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
-			{
-				dstream.CopyTo(output);
-			}
-			return output.ToArray();
-		}
-
-		public static object GetEnvVar(string envName, string defaultValue)
-		{
-			if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable(envName)))
-			{
-				return Environment.GetEnvironmentVariable(envName);
-			}
-			else
-			{
-				return defaultValue;
-			}
-		}
-	}
-
-	/// <summary>
-	/// Provides a way to set contextual data that flows with the call and 
-	/// async context of a test or invocation.
-	/// </summary>
-	public static class CallContext
-	{
-		static ConcurrentDictionary<string, AsyncLocal<object>> state = new ConcurrentDictionary<string, AsyncLocal<object>>();
-
-		/// <summary>
-		/// Stores a given object and associates it with the specified name.
-		/// </summary>
-		/// <param name="name">The name with which to associate the new item in the call context.</param>
-		/// <param name="data">The object to store in the call context.</param>
-		public static void SetData(string name, object data) =>
-			state.GetOrAdd(name, _ => new AsyncLocal<object>()).Value = data;
-
-		/// <summary>
-		/// Retrieves an object with the specified name from the <see cref="CallContext"/>.
-		/// </summary>
-		/// <param name="name">The name of the item in the call context.</param>
-		/// <returns>The object in the call context associated with the specified name, or <see langword="null"/> if not found.</returns>
-		public static object GetData(string name) =>
-			state.TryGetValue(name, out AsyncLocal<object> data) ? data.Value : null;
-	}
-}

gaseous-server/Classes/Config.cs

@@ -1,787 +0,0 @@
-using System;
-using System.Data;
-using Newtonsoft.Json;
-using IGDB.Models;
-using gaseous_server.Classes.Metadata;
-using NuGet.Common;
-
-namespace gaseous_server.Classes
-{
-    public static class Config
-    {
-        static ConfigFile _config;
-
-        public static string ConfigurationPath
-        {
-            get
-            {
-                return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".gaseous-server");
-            }
-        }
-
-        static string ConfigurationFilePath
-        {
-            get
-            {
-                return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".gaseous-server", "config.json");
-            }
-        }
-
-        static string ConfigurationFilePath_Backup
-        {
-            get
-            {
-                return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".gaseous-server", "config.json.backup");
-            }
-        }
-
-        public static string PlatformMappingFile
-        {
-            get
-            {
-                return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".gaseous-server", "platformmap.json");
-            }
-        }
-
-        public static ConfigFile.Database DatabaseConfiguration
-        {
-            get
-            {
-                return _config.DatabaseConfiguration;
-            }
-        }
-
-        public static ConfigFile.Library LibraryConfiguration
-        {
-            get
-            {
-                return _config.LibraryConfiguration;
-            }
-        }
-
-        public static ConfigFile.MetadataAPI MetadataConfiguration
-        {
-            get
-            {
-                return _config.MetadataConfiguration;
-            }
-        }
-
-        public static ConfigFile.IGDB IGDB
-        {
-            get
-            {
-                return _config.IGDBConfiguration;
-            }
-        }
-
-        public static string LogPath
-        {
-            get
-            {
-                string logPath = Path.Combine(ConfigurationPath, "Logs");
-                if (!Directory.Exists(logPath))
-                {
-                    Directory.CreateDirectory(logPath);
-                }
-                return logPath;
-            }
-        }
-
-        public static string LogFilePath
-        {
-            get
-            {
-                string logFileExtension = "txt";
-
-                string logPathName = Path.Combine(LogPath, "Server Log " + DateTime.Now.ToUniversalTime().ToString("yyyyMMdd") + "." + logFileExtension);
-                return logPathName;
-            }
-        }
-
-        public static ConfigFile.Logging LoggingConfiguration
-        {
-            get
-            {
-                return _config.LoggingConfiguration;
-            }
-        }
-
-        static Config()
-        {
-            if (_config == null)
-            {
-                // load the config file
-                if (File.Exists(ConfigurationFilePath))
-                {
-                    string configRaw = File.ReadAllText(ConfigurationFilePath);
-                    ConfigFile? _tempConfig = Newtonsoft.Json.JsonConvert.DeserializeObject<ConfigFile>(configRaw);
-                    if (_tempConfig != null)
-                    {
-                        _config = _tempConfig;
-
-                        // load environment variables if we're in a docker container
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("INDOCKER")))
-                        {
-                            if (Environment.GetEnvironmentVariable("INDOCKER") == "1")
-                            {
-                                Console.WriteLine("Running in Docker - setting configuration from variables");
-                                _config.DatabaseConfiguration.HostName = (string)Common.GetEnvVar("dbhost", _config.DatabaseConfiguration.HostName);
-                                _config.DatabaseConfiguration.UserName = (string)Common.GetEnvVar("dbuser", _config.DatabaseConfiguration.UserName);
-                                _config.DatabaseConfiguration.Password = (string)Common.GetEnvVar("dbpass", _config.DatabaseConfiguration.Password);
-                                _config.DatabaseConfiguration.DatabaseName = (string)Common.GetEnvVar("dbname", _config.DatabaseConfiguration.DatabaseName);
-                                _config.DatabaseConfiguration.Port = int.Parse((string)Common.GetEnvVar("dbport", _config.DatabaseConfiguration.Port.ToString()));
-                                _config.MetadataConfiguration.MetadataSource = (HasheousClient.Models.MetadataModel.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.MetadataSources), (string)Common.GetEnvVar("metadatasource", _config.MetadataConfiguration.MetadataSource.ToString()));
-                                _config.MetadataConfiguration.SignatureSource = (HasheousClient.Models.MetadataModel.SignatureSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.SignatureSources), (string)Common.GetEnvVar("signaturesource", _config.MetadataConfiguration.SignatureSource.ToString())); ;
-                                _config.MetadataConfiguration.MaxLibraryScanWorkers = int.Parse((string)Common.GetEnvVar("maxlibraryscanworkers", _config.MetadataConfiguration.MaxLibraryScanWorkers.ToString()));
-                                _config.MetadataConfiguration.HasheousHost = (string)Common.GetEnvVar("hasheoushost", _config.MetadataConfiguration.HasheousHost);
-                                _config.IGDBConfiguration.ClientId = (string)Common.GetEnvVar("igdbclientid", _config.IGDBConfiguration.ClientId);
-                                _config.IGDBConfiguration.Secret = (string)Common.GetEnvVar("igdbclientsecret", _config.IGDBConfiguration.Secret);
-                            }
-                        }
-                    }
-                    else
-                    {
-                        throw new Exception("There was an error reading the config file: Json returned null");
-                    }
-                }
-                else
-                {
-                    // no config file!
-                    // use defaults and save
-                    _config = new ConfigFile();
-                    UpdateConfig();
-                }
-            }
-
-            Console.WriteLine("Using configuration:");
-            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(_config, Formatting.Indented));
-        }
-
-        public static void UpdateConfig()
-        {
-            // save any updates to the configuration
-            Newtonsoft.Json.JsonSerializerSettings serializerSettings = new Newtonsoft.Json.JsonSerializerSettings
-            {
-                NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
-                Formatting = Newtonsoft.Json.Formatting.Indented
-            };
-            serializerSettings.Converters.Add(new Newtonsoft.Json.Converters.StringEnumConverter());
-            string configRaw = Newtonsoft.Json.JsonConvert.SerializeObject(_config, serializerSettings);
-
-            if (!Directory.Exists(ConfigurationPath))
-            {
-                Directory.CreateDirectory(ConfigurationPath);
-            }
-
-            if (File.Exists(ConfigurationFilePath_Backup))
-            {
-                File.Delete(ConfigurationFilePath_Backup);
-            }
-            if (File.Exists(ConfigurationFilePath))
-            {
-                File.Move(ConfigurationFilePath, ConfigurationFilePath_Backup);
-            }
-            File.WriteAllText(ConfigurationFilePath, configRaw);
-        }
-
-        private static Dictionary<string, object> AppSettings = new Dictionary<string, object>();
-
-        public static void InitSettings()
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT * FROM Settings";
-
-            DataTable dbResponse = db.ExecuteCMD(sql);
-            foreach (DataRow dataRow in dbResponse.Rows)
-            {
-                string SettingName = (string)dataRow["Setting"];
-
-                if (SettingName.StartsWith("LastRun_"))
-                {
-                    Console.WriteLine("Break");
-                }
-
-                if (AppSettings.ContainsKey(SettingName))
-                {
-                    AppSettings.Remove(SettingName);
-                }
-
-                Logging.Log(Logging.LogType.Information, "Load Settings", "Loading setting " + SettingName + " from database");
-
-                try
-                {
-                    if (Database.schema_version >= 1016)
-                    {
-                        switch ((int)dataRow["ValueType"])
-                        {
-                            case 0:
-                            default:
-                                // value is a string
-                                AppSettings.Add(SettingName, dataRow["Value"]);
-                                break;
-
-                            case 1:
-                                // value is a datetime
-                                AppSettings.Add(SettingName, dataRow["ValueDate"]);
-                                break;
-                        }
-                    }
-                    else
-                    {
-                        AppSettings.Add(SettingName, dataRow["Value"]);
-                    }
-                }
-                catch (InvalidCastException castEx)
-                {
-                    Logging.Log(Logging.LogType.Warning, "Settings", "Exception when reading server setting " + SettingName + ". Resetting to default.", castEx);
-
-                    // delete broken setting and return the default
-                    // this error is probably generated during an upgrade
-                    sql = "DELETE FROM Settings WHERE Setting = @SettingName";
-                    Dictionary<string, object> dbDict = new Dictionary<string, object>
-                    {
-                        { "SettingName", SettingName }
-                    };
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Critical, "Settings", "Exception when reading server setting " + SettingName + ".", ex);
-                }
-            }
-        }
-
-        public static T ReadSetting<T>(string SettingName, T DefaultValue)
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            try
-            {
-                if (AppSettings.ContainsKey(SettingName))
-                {
-                    return (T)AppSettings[SettingName];
-                }
-                else
-                {
-                    string sql;
-                    Dictionary<string, object> dbDict = new Dictionary<string, object>
-                    {
-                        { "SettingName", SettingName }
-                    };
-                    DataTable dbResponse;
-
-                    try
-                    {
-                        Logging.Log(Logging.LogType.Debug, "Database", "Reading setting '" + SettingName + "'");
-
-                        if (Database.schema_version >= 1016)
-                        {
-                            sql = "SELECT Value, ValueDate FROM Settings WHERE Setting = @SettingName";
-
-                            dbResponse = db.ExecuteCMD(sql, dbDict);
-                            Type type = typeof(T);
-                            if (dbResponse.Rows.Count == 0)
-                            {
-                                // no value with that name stored - respond with the default value
-                                SetSetting<T>(SettingName, DefaultValue);
-                                return DefaultValue;
-                            }
-                            else
-                            {
-                                if (type.ToString() == "System.DateTime")
-                                {
-                                    AppSettings.Add(SettingName, (T)dbResponse.Rows[0]["ValueDate"]);
-                                    return (T)dbResponse.Rows[0]["ValueDate"];
-                                }
-                                else
-                                {
-                                    AppSettings.Add(SettingName, (T)dbResponse.Rows[0]["Value"]);
-                                    return (T)dbResponse.Rows[0]["Value"];
-                                }
-                            }
-                        }
-                        else
-                        {
-                            sql = "SELECT Value FROM Settings WHERE Setting = @SettingName";
-
-                            dbResponse = db.ExecuteCMD(sql, dbDict);
-                            Type type = typeof(T);
-                            if (dbResponse.Rows.Count == 0)
-                            {
-                                // no value with that name stored - respond with the default value
-                                SetSetting<T>(SettingName, DefaultValue);
-                                return DefaultValue;
-                            }
-                            else
-                            {
-                                AppSettings.Add(SettingName, (T)dbResponse.Rows[0]["Value"]);
-                                return (T)dbResponse.Rows[0]["Value"];
-                            }
-                        }
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Critical, "Database", "Failed reading setting " + SettingName, ex);
-                        throw;
-                    }
-                }
-            }
-            catch (InvalidCastException castEx)
-            {
-                Logging.Log(Logging.LogType.Warning, "Settings", "Exception when reading server setting " + SettingName + ". Resetting to default.", castEx);
-
-                // delete broken setting and return the default
-                // this error is probably generated during an upgrade
-                if (AppSettings.ContainsKey(SettingName))
-                {
-                    AppSettings.Remove(SettingName);
-                }
-
-                string sql = "DELETE FROM Settings WHERE Setting = @SettingName";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>
-                {
-                    { "SettingName", SettingName }
-                };
-
-                return DefaultValue;
-            }
-            catch (Exception ex)
-            {
-                Logging.Log(Logging.LogType.Critical, "Settings", "Exception when reading server setting " + SettingName + ".", ex);
-                throw;
-            }
-        }
-
-        public static void SetSetting<T>(string SettingName, T Value)
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql;
-            Dictionary<string, object> dbDict;
-
-            if (Database.schema_version >= 1016)
-            {
-                sql = "REPLACE INTO Settings (Setting, ValueType, Value, ValueDate) VALUES (@SettingName, @ValueType, @Value, @ValueDate)";
-                Type type = typeof(T);
-                if (type.ToString() == "System.DateTime")
-                {
-                    dbDict = new Dictionary<string, object>
-                    {
-                        { "SettingName", SettingName },
-                        { "ValueType", 1 },
-                        { "Value", null },
-                        { "ValueDate", Value }
-                    };
-                }
-                else
-                {
-                    dbDict = new Dictionary<string, object>
-                    {
-                        { "SettingName", SettingName },
-                        { "ValueType", 0 },
-                        { "Value", Value },
-                        { "ValueDate", null }
-                    };
-                }
-            }
-            else
-            {
-                sql = "REPLACE INTO Settings (Setting, Value) VALUES (@SettingName, @Value)";
-                dbDict = new Dictionary<string, object>
-                {
-                    { "SettingName", SettingName },
-                    { "Value", Value }
-                };
-            }
-
-            Logging.Log(Logging.LogType.Debug, "Database", "Storing setting '" + SettingName + "' to value: '" + Value + "'");
-            try
-            {
-                db.ExecuteCMD(sql, dbDict);
-
-                if (AppSettings.ContainsKey(SettingName))
-                {
-                    AppSettings[SettingName] = Value;
-                }
-                else
-                {
-                    AppSettings.Add(SettingName, Value);
-                }
-            }
-            catch (Exception ex)
-            {
-                Logging.Log(Logging.LogType.Critical, "Database", "Failed storing setting" + SettingName, ex);
-                throw;
-            }
-        }
-
-        public class ConfigFile
-        {
-            public Database DatabaseConfiguration = new Database();
-
-            [JsonIgnore]
-            public Library LibraryConfiguration = new Library();
-
-            public MetadataAPI MetadataConfiguration = new MetadataAPI();
-
-            public IGDB IGDBConfiguration = new IGDB();
-
-            public Logging LoggingConfiguration = new Logging();
-
-            public class Database
-            {
-                private static string _DefaultHostName
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbhost")))
-                        {
-                            return Environment.GetEnvironmentVariable("dbhost");
-                        }
-                        else
-                        {
-                            return "localhost";
-                        }
-                    }
-                }
-
-                private static string _DefaultUserName
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbuser")))
-                        {
-                            return Environment.GetEnvironmentVariable("dbuser");
-                        }
-                        else
-                        {
-                            return "gaseous";
-                        }
-                    }
-                }
-
-                private static string _DefaultPassword
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbpass")))
-                        {
-                            return Environment.GetEnvironmentVariable("dbpass");
-                        }
-                        else
-                        {
-                            return "gaseous";
-                        }
-                    }
-                }
-
-                private static string _DefaultDatabaseName
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbname")))
-                        {
-                            return Environment.GetEnvironmentVariable("dbname");
-                        }
-                        else
-                        {
-                            return "gaseous";
-                        }
-                    }
-                }
-
-                private static int _DefaultDatabasePort
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbport")))
-                        {
-                            return int.Parse(Environment.GetEnvironmentVariable("dbport"));
-                        }
-                        else
-                        {
-                            return 3306;
-                        }
-                    }
-                }
-
-                public string HostName = _DefaultHostName;
-                public string UserName = _DefaultUserName;
-                public string Password = _DefaultPassword;
-                public string DatabaseName = _DefaultDatabaseName;
-                public int Port = _DefaultDatabasePort;
-
-                [JsonIgnore]
-                public string ConnectionString
-                {
-                    get
-                    {
-                        string dbConnString = "server=" + HostName + ";port=" + Port + ";userid=" + UserName + ";password=" + Password + ";database=" + DatabaseName + "";
-                        return dbConnString;
-                    }
-                }
-
-                [JsonIgnore]
-                public string ConnectionStringNoDatabase
-                {
-                    get
-                    {
-                        string dbConnString = "server=" + HostName + ";port=" + Port + ";userid=" + UserName + ";password=" + Password + ";";
-                        return dbConnString;
-                    }
-                }
-            }
-
-            public class Library
-            {
-                public string LibraryRootDirectory
-                {
-                    get
-                    {
-                        return ReadSetting<string>("LibraryRootDirectory", Path.Combine(Config.ConfigurationPath, "Data"));
-                    }
-                    set
-                    {
-                        SetSetting<string>("LibraryRootDirectory", value);
-                    }
-                }
-
-                public string LibraryImportDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Import");
-                    }
-                }
-
-                public string LibraryImportErrorDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Import Errors");
-                    }
-                }
-
-                public string LibraryImportDuplicatesDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryImportErrorDirectory, "Duplicates");
-                    }
-                }
-
-                public string LibraryImportGeneralErrorDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryImportErrorDirectory, "Error");
-                    }
-                }
-
-                public string LibraryBIOSDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "BIOS");
-                    }
-                }
-
-                public string LibraryUploadDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Upload");
-                    }
-                }
-
-                public string LibraryMetadataDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Metadata");
-                    }
-                }
-
-                public string LibraryTempDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Temp");
-                    }
-                }
-
-                public string LibraryCollectionsDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Collections");
-                    }
-                }
-
-                public string LibraryMediaGroupDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Media Groups");
-                    }
-                }
-
-                public string LibraryMetadataDirectory_Platform(Platform platform)
-                {
-                    string MetadataPath = Path.Combine(LibraryMetadataDirectory, "Platforms", platform.Slug);
-                    if (!Directory.Exists(MetadataPath)) { Directory.CreateDirectory(MetadataPath); }
-                    return MetadataPath;
-                }
-
-                public string LibraryMetadataDirectory_Game(Game game)
-                {
-                    string MetadataPath = Path.Combine(LibraryMetadataDirectory, "Games", game.Slug);
-                    if (!Directory.Exists(MetadataPath)) { Directory.CreateDirectory(MetadataPath); }
-                    return MetadataPath;
-                }
-
-                public string LibraryMetadataDirectory_Company(Company company)
-                {
-                    string MetadataPath = Path.Combine(LibraryMetadataDirectory, "Companies", company.Slug);
-                    if (!Directory.Exists(MetadataPath)) { Directory.CreateDirectory(MetadataPath); }
-                    return MetadataPath;
-                }
-
-                public string LibrarySignatureImportDirectory
-                {
-                    get
-                    {
-                        return Path.Combine(LibraryRootDirectory, "Signatures");
-                    }
-                }
-
-                public void InitLibrary()
-                {
-                    if (!Directory.Exists(LibraryRootDirectory)) { Directory.CreateDirectory(LibraryRootDirectory); }
-                    if (!Directory.Exists(LibraryImportDirectory)) { Directory.CreateDirectory(LibraryImportDirectory); }
-                    if (!Directory.Exists(LibraryBIOSDirectory)) { Directory.CreateDirectory(LibraryBIOSDirectory); }
-                    if (!Directory.Exists(LibraryUploadDirectory)) { Directory.CreateDirectory(LibraryUploadDirectory); }
-                    if (!Directory.Exists(LibraryMetadataDirectory)) { Directory.CreateDirectory(LibraryMetadataDirectory); }
-                    if (!Directory.Exists(LibraryTempDirectory)) { Directory.CreateDirectory(LibraryTempDirectory); }
-                    if (!Directory.Exists(LibraryCollectionsDirectory)) { Directory.CreateDirectory(LibraryCollectionsDirectory); }
-                    if (!Directory.Exists(LibrarySignatureImportDirectory)) { Directory.CreateDirectory(LibrarySignatureImportDirectory); }
-                }
-            }
-
-            public class MetadataAPI
-            {
-                private static HasheousClient.Models.MetadataModel.MetadataSources _MetadataSource
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("metadatasource")))
-                        {
-                            return (HasheousClient.Models.MetadataModel.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.MetadataSources), Environment.GetEnvironmentVariable("metadatasource"));
-                        }
-                        else
-                        {
-                            return HasheousClient.Models.MetadataModel.MetadataSources.IGDB;
-                        }
-                    }
-                }
-
-                private static HasheousClient.Models.MetadataModel.SignatureSources _SignatureSource
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("signaturesource")))
-                        {
-                            return (HasheousClient.Models.MetadataModel.SignatureSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.SignatureSources), Environment.GetEnvironmentVariable("signaturesource"));
-                        }
-                        else
-                        {
-                            return HasheousClient.Models.MetadataModel.SignatureSources.LocalOnly;
-                        }
-                    }
-                }
-
-                private static int _MaxLibraryScanWorkers
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("maxlibraryscanworkers")))
-                        {
-                            return int.Parse(Environment.GetEnvironmentVariable("maxlibraryscanworkers"));
-                        }
-                        else
-                        {
-                            return 4;
-                        }
-                    }
-                }
-
-                private static string _HasheousHost
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("hasheoushost")))
-                        {
-                            return Environment.GetEnvironmentVariable("hasheoushost");
-                        }
-                        else
-                        {
-                            return "https://hasheous.org/";
-                        }
-                    }
-                }
-
-                public HasheousClient.Models.MetadataModel.MetadataSources MetadataSource = _MetadataSource;
-
-                public HasheousClient.Models.MetadataModel.SignatureSources SignatureSource = _SignatureSource;
-
-                public int MaxLibraryScanWorkers = _MaxLibraryScanWorkers;
-
-                public string HasheousHost = _HasheousHost;
-            }
-
-            public class IGDB
-            {
-                private static string _DefaultIGDBClientId
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("igdbclientid")))
-                        {
-                            return Environment.GetEnvironmentVariable("igdbclientid");
-                        }
-                        else
-                        {
-                            return "";
-                        }
-                    }
-                }
-
-                private static string _DefaultIGDBSecret
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("igdbclientsecret")))
-                        {
-                            return Environment.GetEnvironmentVariable("igdbclientsecret");
-                        }
-                        else
-                        {
-                            return "";
-                        }
-                    }
-                }
-
-                public string ClientId = _DefaultIGDBClientId;
-                public string Secret = _DefaultIGDBSecret;
-            }
-
-            public class Logging
-            {
-                public bool DebugLogging = false;
-
-                // log retention in days
-                public int LogRetention = 7;
-
-                public bool AlwaysLogToDisk = false;
-            }
-        }
-    }
-}

gaseous-server/Classes/Database.cs

@@ -1,505 +0,0 @@
-using System;
-using System.Data;
-using System.Data.SqlClient;
-using System.Diagnostics;
-using System.Reflection;
-using MySqlConnector;
-
-namespace gaseous_server.Classes
-{
-	public class Database
-	{
-		private static int _schema_version { get; set; } = 0;
-		public static int schema_version
-		{
-			get
-			{
-				//Logging.Log(Logging.LogType.Information, "Database Schema", "Schema version is " + _schema_version);
-				return _schema_version;
-			}
-			set
-			{
-				//Logging.Log(Logging.LogType.Information, "Database Schema", "Setting schema version " + _schema_version);
-				_schema_version = value;
-			}
-		}
-		
-		public Database()
-		{
-
-		}
-
-		public Database(databaseType Type, string ConnectionString)
-		{
-			_ConnectorType = Type;
-			_ConnectionString = ConnectionString;
-		}
-
-		public enum databaseType
-		{
-			MySql
-		}
-
-		string _ConnectionString = "";
-
-		public string ConnectionString
-		{
-			get
-			{
-				return _ConnectionString;
-			}
-			set
-			{
-				_ConnectionString = value;
-			}
-		}
-
-		databaseType? _ConnectorType = null;
-
-		public databaseType? ConnectorType
-		{
-			get
-			{
-				return _ConnectorType;
-			}
-			set
-			{
-				_ConnectorType = value;
-			}
-		}
-
-		public void InitDB()
-		{
-            // load resources
-            var assembly = Assembly.GetExecutingAssembly();
-
-            switch (_ConnectorType)
-			{
-				case databaseType.MySql:
-					// check if the database exists first - first run must have permissions to create a database
-					string sql = "CREATE DATABASE IF NOT EXISTS `" + Config.DatabaseConfiguration.DatabaseName + "`;";
-					Dictionary<string, object> dbDict = new Dictionary<string, object>();
-					Logging.Log(Logging.LogType.Information, "Database", "Creating database if it doesn't exist");
-					ExecuteCMD(sql, dbDict, 30, "server=" + Config.DatabaseConfiguration.HostName + ";port=" + Config.DatabaseConfiguration.Port + ";userid=" + Config.DatabaseConfiguration.UserName + ";password=" + Config.DatabaseConfiguration.Password);
-
-					// check if schema version table is in place - if not, create the schema version table
-					sql = "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = '" + Config.DatabaseConfiguration.DatabaseName + "' AND TABLE_NAME = 'schema_version';";
-					DataTable SchemaVersionPresent = ExecuteCMD(sql, dbDict);
-					if (SchemaVersionPresent.Rows.Count == 0)
-					{
-                        // no schema table present - create it
-                        Logging.Log(Logging.LogType.Information, "Database", "Schema version table doesn't exist. Creating it.");
-                        sql = "CREATE TABLE `schema_version` (`schema_version` INT NOT NULL, PRIMARY KEY (`schema_version`)); INSERT INTO `schema_version` (`schema_version`) VALUES (0);";
-						ExecuteCMD(sql, dbDict);
-					}
-
-					sql = "SELECT schema_version FROM schema_version;";
-					dbDict = new Dictionary<string, object>();
-					DataTable SchemaVersion = ExecuteCMD(sql, dbDict);
-					int OuterSchemaVer = (int)SchemaVersion.Rows[0][0];
-					if (OuterSchemaVer == 0)
-					{
-						OuterSchemaVer = 1000;
-					}
-
-                    for (int i = OuterSchemaVer; i < 10000; i++)
-					{
-						string resourceName = "gaseous_server.Support.Database.MySQL.gaseous-" + i + ".sql";
-						string dbScript = "";
-
-						string[] resources = Assembly.GetExecutingAssembly().GetManifestResourceNames();
-						if (resources.Contains(resourceName))
-						{
-							using (Stream stream = assembly.GetManifestResourceStream(resourceName))
-							using (StreamReader reader = new StreamReader(stream))
-							{
-                                dbScript = reader.ReadToEnd();
-
-								// apply script
-								sql = "SELECT schema_version FROM schema_version;";
-								dbDict = new Dictionary<string, object>();
-								SchemaVersion = ExecuteCMD(sql, dbDict);
-								if (SchemaVersion.Rows.Count == 0)
-								{
-                                    // something is broken here... where's the table?
-                                    Logging.Log(Logging.LogType.Critical, "Database", "Schema table missing! This shouldn't happen!");
-                                    throw new Exception("schema_version table is missing!");
-								}
-								else
-								{
-									int SchemaVer = (int)SchemaVersion.Rows[0][0];
-                                    Logging.Log(Logging.LogType.Information, "Database", "Schema version is " + SchemaVer);
-									// update schema version variable
-									Database.schema_version = SchemaVer;
-                                    if (SchemaVer < i)
-									{
-										try
-										{
-											// run pre-upgrade code
-											DatabaseMigration.PreUpgradeScript(i, _ConnectorType);
-											
-											// apply schema!
-											Logging.Log(Logging.LogType.Information, "Database", "Updating schema to version " + i);
-											ExecuteCMD(dbScript, dbDict, 180);
-
-											sql = "UPDATE schema_version SET schema_version=@schemaver";
-											dbDict = new Dictionary<string, object>();
-											dbDict.Add("schemaver", i);
-											ExecuteCMD(sql, dbDict);
-
-											// run post-upgrade code
-											DatabaseMigration.PostUpgradeScript(i, _ConnectorType);
-
-											// update schema version variable
-											Database.schema_version = i;
-										}
-										catch (Exception ex)
-										{
-											Logging.Log(Logging.LogType.Critical, "Database", "Schema upgrade failed! Unable to continue.", ex);
-											System.Environment.Exit(1);
-										}
-									}
-								}
-							}
-						}
-                    }
-                    Logging.Log(Logging.LogType.Information, "Database", "Database setup complete");
-                    break;
-			}
-		}
-
-        public DataTable ExecuteCMD(string Command)
-		{
-			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			return _ExecuteCMD(Command, dbDict, 30, "");
-		}
-
-        public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters)
-        {
-            return _ExecuteCMD(Command, Parameters, 30, "");
-        }
-
-        public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-			return _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
-        }
-
-		public List<Dictionary<string, object>> ExecuteCMDDict(string Command)
-		{
-			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			return _ExecuteCMDDict(Command, dbDict, 30, "");
-		}
-
-        public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters)
-        {
-            return _ExecuteCMDDict(Command, Parameters, 30, "");
-        }
-
-        public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-			return _ExecuteCMDDict(Command, Parameters, Timeout, ConnectionString);
-        }
-
-		private List<Dictionary<string, object>> _ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-		{
-			DataTable dataTable = _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
-
-			// convert datatable to dictionary
-			List<Dictionary<string, object?>> rows = new List<Dictionary<string, object?>>();
-
-			foreach (DataRow dataRow in dataTable.Rows)
-			{
-				Dictionary<string, object?> row = new Dictionary<string, object?>();
-				for (int i = 0; i < dataRow.Table.Columns.Count; i++)
-				{
-					string columnName = dataRow.Table.Columns[i].ColumnName;
-					if (dataRow[i] == System.DBNull.Value)
-					{
-						row.Add(columnName, null);
-					}
-					else
-					{
-						row.Add(columnName, dataRow[i].ToString());
-					}
-				}
-				rows.Add(row);
-			}
-
-			return rows;
-		}
-
-        private DataTable _ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-            if (ConnectionString == "") { ConnectionString = _ConnectionString; }
-            switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
-                    return (DataTable)conn.ExecCMD(Command, Parameters, Timeout);
-                default:
-                    return new DataTable();
-            }
-        }
-
-		public int ExecuteNonQuery(string Command)
-		{
-			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			return _ExecuteNonQuery(Command, dbDict, 30, "");
-		}
-
-        public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters)
-        {
-            return _ExecuteNonQuery(Command, Parameters, 30, "");
-        }
-
-        public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-			return _ExecuteNonQuery(Command, Parameters, Timeout, ConnectionString);
-        }
-
-        private int _ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
-        {
-            if (ConnectionString == "") { ConnectionString = _ConnectionString; }
-            switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
-					int retVal = conn.ExecNonQuery(Command, Parameters, Timeout); 
-                    return retVal;
-                default:
-                    return 0;
-            }
-        }
-
-        public void ExecuteTransactionCMD(List<SQLTransactionItem> CommandList, int Timeout = 60)
-        {
-            object conn;
-            switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    {
-                        var commands = new List<Dictionary<string, object>>();
-                        foreach (SQLTransactionItem CommandItem in CommandList)
-                        {
-                            var nCmd = new Dictionary<string, object>();
-                            nCmd.Add("sql", CommandItem.SQLCommand);
-                            nCmd.Add("values", CommandItem.Parameters);
-                            commands.Add(nCmd);
-                        }
-
-                        conn = new MySQLServerConnector(_ConnectionString);
-                        ((MySQLServerConnector)conn).TransactionExecCMD(commands, Timeout);
-                        break;
-                    }
-            }
-        }
-
-		public int GetDatabaseSchemaVersion()
-		{
-			switch (_ConnectorType)
-			{
-				case databaseType.MySql:
-					string sql = "SELECT schema_version FROM schema_version;";
-					DataTable SchemaVersion = ExecuteCMD(sql);
-					if (SchemaVersion.Rows.Count == 0)
-					{
-						return 0;
-					}
-					else
-					{
-						return (int)SchemaVersion.Rows[0][0];
-					}
-					
-				default:
-					return 0;
-
-			}
-		}
-
-		public bool TestConnection()
-		{
-			switch (_ConnectorType)
-            {
-                case databaseType.MySql:
-                    MySQLServerConnector conn = new MySQLServerConnector(_ConnectionString);
-                    return conn.TestConnection();
-                default:
-                    return false;
-            }
-		}
-
-        public class SQLTransactionItem
-        {
-			public SQLTransactionItem()
-			{
-
-			}
-
-			public SQLTransactionItem(string SQLCommand, Dictionary<string, object> Parameters)
-			{
-				this.SQLCommand = SQLCommand;
-				this.Parameters = Parameters;
-			}
-
-            public string? SQLCommand;
-            public Dictionary<string, object>? Parameters = new Dictionary<string, object>();
-        }
-
-        private partial class MySQLServerConnector
-		{
-			private string DBConn = "";
-
-			public MySQLServerConnector(string ConnectionString)
-			{
-				DBConn = ConnectionString;
-			}
-
-			public DataTable ExecCMD(string SQL, Dictionary<string, object> Parameters, int Timeout)
-			{
-				DataTable RetTable = new DataTable();
-
-                Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
-                using (MySqlConnection conn = new MySqlConnection(DBConn))
-				{
-					conn.Open();
-
-					MySqlCommand cmd = new MySqlCommand
-					{
-						Connection = conn,
-						CommandText = SQL,
-						CommandTimeout = Timeout
-					};
-
-					foreach (string Parameter in Parameters.Keys)
-					{
-						cmd.Parameters.AddWithValue(Parameter, Parameters[Parameter]);
-					}
-
-					try
-					{
-						Logging.Log(Logging.LogType.Debug, "Database", "Executing sql: '" + SQL + "'", null, true);
-						if (Parameters.Count > 0)
-						{
-							string dictValues = string.Join(";", Parameters.Select(x => string.Join("=", x.Key, x.Value)));
-							Logging.Log(Logging.LogType.Debug, "Database", "Parameters: " + dictValues, null, true);
-						}
-						RetTable.Load(cmd.ExecuteReader());
-					} catch (Exception ex) {
-						Logging.Log(Logging.LogType.Critical, "Database", "Error while executing '" + SQL + "'", ex);
-						Trace.WriteLine("Error executing " + SQL);
-						Trace.WriteLine("Full exception: " + ex.ToString());
-					}
-
-					Logging.Log(Logging.LogType.Debug, "Database", "Closing database connection", null, true);
-					conn.Close();
-				}
-
-				return RetTable;
-			}
-
-			public int ExecNonQuery(string SQL, Dictionary< string, object> Parameters, int Timeout)
-			{
-				int result = 0;
-
-                Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
-                using (MySqlConnection conn = new MySqlConnection(DBConn))
-				{
-					conn.Open();
-
-					MySqlCommand cmd = new MySqlCommand
-					{
-						Connection = conn,
-						CommandText = SQL,
-						CommandTimeout = Timeout
-					};
-
-					foreach (string Parameter in Parameters.Keys)
-					{
-						cmd.Parameters.AddWithValue(Parameter, Parameters[Parameter]);
-					}
-
-					try
-					{
-						Logging.Log(Logging.LogType.Debug, "Database", "Executing sql: '" + SQL + "'", null, true);
-						if (Parameters.Count > 0)
-						{
-							string dictValues = string.Join(";", Parameters.Select(x => string.Join("=", x.Key, x.Value)));
-							Logging.Log(Logging.LogType.Debug, "Database", "Parameters: " + dictValues, null, true);
-						}
-						result = cmd.ExecuteNonQuery();
-					} catch (Exception ex) {
-						Logging.Log(Logging.LogType.Critical, "Database", "Error while executing '" + SQL + "'", ex);
-						Trace.WriteLine("Error executing " + SQL);
-						Trace.WriteLine("Full exception: " + ex.ToString());
-					}
-
-					Logging.Log(Logging.LogType.Debug, "Database", "Closing database connection", null, true);
-					conn.Close();
-				}
-
-				return result;
-			}
-
-            public void TransactionExecCMD(List<Dictionary<string, object>> Parameters, int Timeout)
-            {
-                using (MySqlConnection conn = new MySqlConnection(DBConn))
-                {
-					conn.Open();
-					var command = conn.CreateCommand();
-					MySqlTransaction transaction;
-					transaction = conn.BeginTransaction();
-					command.Connection = conn;
-					command.Transaction = transaction;
-					foreach (Dictionary<string, object> Parameter in Parameters)
-					{
-						var cmd = buildcommand(conn, Parameter["sql"].ToString(), (Dictionary<string, object>)Parameter["values"], Timeout);
-						cmd.Transaction = transaction;
-						cmd.ExecuteNonQuery();
-					}
-
-					transaction.Commit();
-					conn.Close();
-				}
-            }
-
-            private MySqlCommand buildcommand(MySqlConnection Conn, string SQL, Dictionary<string, object> Parameters, int Timeout)
-            {
-                var cmd = new MySqlCommand();
-                cmd.Connection = Conn;
-                cmd.CommandText = SQL;
-                cmd.CommandTimeout = Timeout;
-                {
-                    var withBlock = cmd.Parameters;
-                    if (Parameters is object)
-                    {
-                        if (Parameters.Count > 0)
-                        {
-                            foreach (string param in Parameters.Keys)
-                                withBlock.AddWithValue(param, Parameters[param]);
-                        }
-                    }
-                }
-
-                return cmd;
-            }
-
-			public bool TestConnection()
-			{
-				using (MySqlConnection conn = new MySqlConnection(DBConn))
-				{
-					try
-					{
-						conn.Open();
-						conn.Close();
-						return true;
-					}
-					catch
-					{
-						return false;
-					}
-				}
-			}
-        }
-    }
-}
-

gaseous-server/Classes/Favourites.cs

@@ -1,58 +0,0 @@
-using IGDB.Models;
-
-namespace gaseous_server.Classes
-{
-    public class Favourites
-    {
-        public bool GetFavourite(string userid, long GameId)
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT * FROM Favourites WHERE UserId=@userid AND GameId=@gameid";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>{
-                { "userid", userid },
-                { "gameid", GameId}
-            };
-
-            if (db.ExecuteCMD(sql, dbDict).Rows.Count > 0)
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        public bool SetFavourite(string userid, long GameId, bool Favourite)
-        {
-            bool CurrentFavourite = GetFavourite(userid, GameId);
-            if (CurrentFavourite == Favourite)
-            {
-                return Favourite;
-            }
-            else
-            {
-                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-                string sql;
-                Dictionary<string, object> dbDict = new Dictionary<string, object>{
-                    { "userid", userid },
-                    { "gameid", GameId}
-                };
-
-                if (CurrentFavourite == true)
-                {
-                    // delete existing value
-                    sql = "DELETE FROM Favourites WHERE UserId=@userid AND GameId=@gameid";
-                }
-                else
-                {
-                    // insert new value
-                    sql = "INSERT INTO Favourites (UserId, GameId) VALUES (@userid, @gameid)";
-                }
-                db.ExecuteNonQuery(sql, dbDict);
-
-                return Favourite;
-            }
-        }
-    }
-}

gaseous-server/Classes/FileSignature.cs

@@ -1,384 +0,0 @@
-using System.Collections.Concurrent;
-using System.IO.Compression;
-using HasheousClient.Models;
-using NuGet.Common;
-using SevenZip;
-using SharpCompress.Archives;
-using SharpCompress.Archives.Rar;
-using SharpCompress.Archives.Zip;
-using SharpCompress.Common;
-
-namespace gaseous_server.Classes
-{
-    public class FileSignature
-    {
-        public gaseous_server.Models.Signatures_Games GetFileSignature(GameLibrary.LibraryItem library, Common.hashObject hash, FileInfo fi, string GameFileImportPath)
-        {
-            Logging.Log(Logging.LogType.Information, "Get Signature", "Getting signature for file: " + GameFileImportPath);
-            gaseous_server.Models.Signatures_Games discoveredSignature = new gaseous_server.Models.Signatures_Games();
-            discoveredSignature = _GetFileSignature(hash, fi.Name, fi.Extension, fi.Length, GameFileImportPath, false);
-
-            string[] CompressionExts = { ".zip", ".rar", ".7z" };
-            string ImportedFileExtension = Path.GetExtension(GameFileImportPath);
-
-            if (CompressionExts.Contains(ImportedFileExtension) && (fi.Length < 1073741824))
-            {
-                // file is a zip and less than 1 GiB
-                // extract the zip file and search the contents
-
-                string ExtractPath = Path.Combine(Config.LibraryConfiguration.LibraryTempDirectory, library.Id.ToString(), Path.GetRandomFileName());
-                Logging.Log(Logging.LogType.Information, "Get Signature", "Decompressing " + GameFileImportPath + " to " + ExtractPath + " examine contents");
-                if (!Directory.Exists(ExtractPath)) { Directory.CreateDirectory(ExtractPath); }
-                try
-                {
-                    switch (ImportedFileExtension)
-                    {
-                        case ".zip":
-                            Logging.Log(Logging.LogType.Information, "Get Signature", "Decompressing using zip");
-                            try
-                            {
-                                using (var archive = SharpCompress.Archives.Zip.ZipArchive.Open(GameFileImportPath))
-                                {
-                                    foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
-                                    {
-                                        Logging.Log(Logging.LogType.Information, "Get Signature", "Extracting file: " + entry.Key);
-                                        entry.WriteToDirectory(ExtractPath, new ExtractionOptions()
-                                        {
-                                            ExtractFullPath = true,
-                                            Overwrite = true
-                                        });
-                                    }
-                                }
-                            }
-                            catch (Exception zipEx)
-                            {
-                                Logging.Log(Logging.LogType.Warning, "Get Signature", "Unzip error", zipEx);
-                                throw;
-                            }
-                            break;
-
-                        case ".rar":
-                            Logging.Log(Logging.LogType.Information, "Get Signature", "Decompressing using rar");
-                            try
-                            {
-                                using (var archive = RarArchive.Open(GameFileImportPath))
-                                {
-                                    foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
-                                    {
-                                        Logging.Log(Logging.LogType.Information, "Get Signature", "Extracting file: " + entry.Key);
-                                        entry.WriteToDirectory(ExtractPath, new ExtractionOptions()
-                                        {
-                                            ExtractFullPath = true,
-                                            Overwrite = true
-                                        });
-                                    }
-                                }
-                            }
-                            catch (Exception zipEx)
-                            {
-                                Logging.Log(Logging.LogType.Warning, "Get Signature", "Unrar error", zipEx);
-                                throw;
-                            }
-                            break;
-
-                        case ".7z":
-                            Logging.Log(Logging.LogType.Information, "Get Signature", "Decompressing using 7z");
-                            try
-                            {
-                                using (var archive = SharpCompress.Archives.SevenZip.SevenZipArchive.Open(GameFileImportPath))
-                                {
-                                    foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
-                                    {
-                                        Logging.Log(Logging.LogType.Information, "Get Signature", "Extracting file: " + entry.Key);
-                                        entry.WriteToDirectory(ExtractPath, new ExtractionOptions()
-                                        {
-                                            ExtractFullPath = true,
-                                            Overwrite = true
-                                        });
-                                    }
-                                }
-                            }
-                            catch (Exception zipEx)
-                            {
-                                Logging.Log(Logging.LogType.Warning, "Get Signature", "7z error", zipEx);
-                                throw;
-                            }
-                            break;
-                    }
-
-                    Logging.Log(Logging.LogType.Information, "Get Signature", "Processing decompressed files for signature matches");
-                    // loop through contents until we find the first signature match
-                    List<ArchiveData> archiveFiles = new List<ArchiveData>();
-                    bool signatureFound = false;
-                    foreach (string file in Directory.GetFiles(ExtractPath, "*.*", SearchOption.AllDirectories))
-                    {
-                        if (File.Exists(file))
-                        {
-                            FileInfo zfi = new FileInfo(file);
-                            Common.hashObject zhash = new Common.hashObject(file);
-
-                            Logging.Log(Logging.LogType.Information, "Get Signature", "Checking signature of decompressed file " + file);
-
-                            if (zfi != null)
-                            {
-                                ArchiveData archiveData = new ArchiveData
-                                {
-                                    FileName = Path.GetFileName(file),
-                                    FilePath = zfi.Directory.FullName.Replace(ExtractPath, ""),
-                                    Size = zfi.Length,
-                                    MD5 = hash.md5hash,
-                                    SHA1 = hash.sha1hash
-                                };
-                                archiveFiles.Add(archiveData);
-
-                                if (signatureFound == false)
-                                {
-                                    gaseous_server.Models.Signatures_Games zDiscoveredSignature = _GetFileSignature(zhash, zfi.Name, zfi.Extension, zfi.Length, file, true);
-                                    zDiscoveredSignature.Rom.Name = Path.ChangeExtension(zDiscoveredSignature.Rom.Name, ImportedFileExtension);
-
-                                    if (zDiscoveredSignature.Score > discoveredSignature.Score)
-                                    {
-                                        if (
-                                            zDiscoveredSignature.Rom.SignatureSource == gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType.MAMEArcade ||
-                                            zDiscoveredSignature.Rom.SignatureSource == gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType.MAMEMess
-                                        )
-                                        {
-                                            zDiscoveredSignature.Rom.Name = zDiscoveredSignature.Game.Description + ImportedFileExtension;
-                                        }
-                                        zDiscoveredSignature.Rom.Crc = discoveredSignature.Rom.Crc;
-                                        zDiscoveredSignature.Rom.Md5 = discoveredSignature.Rom.Md5;
-                                        zDiscoveredSignature.Rom.Sha1 = discoveredSignature.Rom.Sha1;
-                                        zDiscoveredSignature.Rom.Size = discoveredSignature.Rom.Size;
-                                        discoveredSignature = zDiscoveredSignature;
-
-                                        signatureFound = true;
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    discoveredSignature.Rom.Attributes.Add(new KeyValuePair<string, object>(
-                         "ZipContents", Newtonsoft.Json.JsonConvert.SerializeObject(archiveFiles)
-                    ));
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Critical, "Get Signature", "Error processing compressed file: " + GameFileImportPath, ex);
-                }
-            }
-
-            return discoveredSignature;
-        }
-
-        private gaseous_server.Models.Signatures_Games _GetFileSignature(Common.hashObject hash, string ImageName, string ImageExtension, long ImageSize, string GameFileImportPath, bool IsInZip)
-        {
-            Logging.Log(Logging.LogType.Information, "Import Game", "Checking signature for file: " + GameFileImportPath + "\nMD5 hash: " + hash.md5hash + "\nSHA1 hash: " + hash.sha1hash);
-
-
-            gaseous_server.Models.Signatures_Games discoveredSignature = new gaseous_server.Models.Signatures_Games();
-
-            // do database search first
-            gaseous_server.Models.Signatures_Games? dbSignature = _GetFileSignatureFromDatabase(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
-
-            if (dbSignature != null)
-            {
-                // local signature found
-                Logging.Log(Logging.LogType.Information, "Import Game", "Signature found in local database for game: " + dbSignature.Game.Name);
-                discoveredSignature = dbSignature;
-            }
-            else
-            {
-                // no local signature attempt to pull from Hasheous
-                dbSignature = _GetFileSignatureFromHasheous(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
-
-                if (dbSignature != null)
-                {
-                    // signature retrieved from Hasheous
-                    Logging.Log(Logging.LogType.Information, "Import Game", "Signature retrieved from Hasheous for game: " + dbSignature.Game.Name);
-
-                    discoveredSignature = dbSignature;
-                }
-                else
-                {
-                    // construct a signature from file data
-                    dbSignature = _GetFileSignatureFromFileData(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
-                    Logging.Log(Logging.LogType.Information, "Import Game", "Signature generated from provided file for game: " + dbSignature.Game.Name);
-
-                    discoveredSignature = dbSignature;
-                }
-            }
-
-            gaseous_server.Models.PlatformMapping.GetIGDBPlatformMapping(ref discoveredSignature, ImageExtension, false);
-
-            Logging.Log(Logging.LogType.Information, "Import Game", "  Determined import file as: " + discoveredSignature.Game.Name + " (" + discoveredSignature.Game.Year + ") " + discoveredSignature.Game.System);
-            Logging.Log(Logging.LogType.Information, "Import Game", "  Platform determined to be: " + discoveredSignature.Flags.IGDBPlatformName + " (" + discoveredSignature.Flags.IGDBPlatformId + ")");
-
-            return discoveredSignature;
-        }
-
-        private gaseous_server.Models.Signatures_Games? _GetFileSignatureFromDatabase(Common.hashObject hash, string ImageName, string ImageExtension, long ImageSize, string GameFileImportPath)
-        {
-            Logging.Log(Logging.LogType.Information, "Get Signature", "Checking local database for MD5: " + hash.md5hash);
-
-            // check 1: do we have a signature for it?
-            gaseous_server.Classes.SignatureManagement sc = new SignatureManagement();
-            List<gaseous_server.Models.Signatures_Games> signatures = sc.GetSignature(hash.md5hash);
-            if (signatures == null || signatures.Count == 0)
-            {
-                Logging.Log(Logging.LogType.Information, "Get Signature", "Checking local database for SHA1: " + hash.sha1hash);
-
-                // no md5 signature found - try sha1
-                signatures = sc.GetSignature("", hash.sha1hash);
-            }
-
-            gaseous_server.Models.Signatures_Games? discoveredSignature = null;
-            if (signatures.Count == 1)
-            {
-                // only 1 signature found!
-                discoveredSignature = signatures.ElementAt(0);
-
-                return discoveredSignature;
-            }
-            else if (signatures.Count > 1)
-            {
-                // more than one signature found - find one with highest score
-                // start with first returned element
-                discoveredSignature = signatures.First();
-                foreach (gaseous_server.Models.Signatures_Games Sig in signatures)
-                {
-                    if (Sig.Score > discoveredSignature.Score)
-                    {
-                        discoveredSignature = Sig;
-                    }
-                }
-
-                return discoveredSignature;
-            }
-
-            return null;
-        }
-
-        private gaseous_server.Models.Signatures_Games? _GetFileSignatureFromHasheous(Common.hashObject hash, string ImageName, string ImageExtension, long ImageSize, string GameFileImportPath)
-        {
-            // check if hasheous is enabled, and if so use it's signature database
-            if (Config.MetadataConfiguration.SignatureSource == HasheousClient.Models.MetadataModel.SignatureSources.Hasheous)
-            {
-                HasheousClient.Hasheous hasheous = new HasheousClient.Hasheous();
-                SignatureLookupItem? HasheousResult = null;
-
-                try
-                {
-                    HasheousResult = hasheous.RetrieveFromHasheousAsync(new HashLookupModel
-                    {
-                        MD5 = hash.md5hash,
-                        SHA1 = hash.sha1hash
-                    });
-
-                    if (HasheousResult != null)
-                    {
-                        if (HasheousResult.Signature != null)
-                        {
-                            gaseous_server.Models.Signatures_Games signature = new Models.Signatures_Games();
-                            signature.Game = HasheousResult.Signature.Game;
-                            signature.Rom = HasheousResult.Signature.Rom;
-
-                            if (HasheousResult.MetadataResults != null)
-                            {
-                                if (HasheousResult.MetadataResults.Count > 0)
-                                {
-                                    foreach (SignatureLookupItem.MetadataResult metadataResult in HasheousResult.MetadataResults)
-                                    {
-                                        if (metadataResult.Source == MetadataModel.MetadataSources.IGDB)
-                                        {
-                                            signature.Flags.IGDBPlatformId = (long)metadataResult.PlatformId;
-                                            signature.Flags.IGDBGameId = (long)metadataResult.GameId;
-                                        }
-                                    }
-                                }
-                            }
-
-                            return signature;
-                        }
-                    }
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
-                }
-            }
-
-            return null;
-        }
-
-        private gaseous_server.Models.Signatures_Games _GetFileSignatureFromFileData(Common.hashObject hash, string ImageName, string ImageExtension, long ImageSize, string GameFileImportPath)
-        {
-            SignatureManagement signatureManagement = new SignatureManagement();
-
-            gaseous_server.Models.Signatures_Games discoveredSignature = new gaseous_server.Models.Signatures_Games();
-
-            // no signature match found - try name search
-            List<gaseous_server.Models.Signatures_Games> signatures = signatureManagement.GetByTosecName(ImageName);
-
-            if (signatures.Count == 1)
-            {
-                // only 1 signature found!
-                discoveredSignature = signatures.ElementAt(0);
-
-                return discoveredSignature;
-            }
-            else if (signatures.Count > 1)
-            {
-                // more than one signature found - find one with highest score
-                foreach (gaseous_server.Models.Signatures_Games Sig in signatures)
-                {
-                    if (Sig.Score > discoveredSignature.Score)
-                    {
-                        discoveredSignature = Sig;
-                    }
-                }
-
-                return discoveredSignature;
-            }
-            else
-            {
-                // still no search - try alternate method
-                gaseous_server.Models.Signatures_Games.GameItem gi = new gaseous_server.Models.Signatures_Games.GameItem();
-                gaseous_server.Models.Signatures_Games.RomItem ri = new gaseous_server.Models.Signatures_Games.RomItem();
-
-                discoveredSignature.Game = gi;
-                discoveredSignature.Rom = ri;
-
-                // game title is the file name without the extension or path
-                gi.Name = Path.GetFileNameWithoutExtension(GameFileImportPath);
-
-                // remove everything after brackets - leaving (hopefully) only the name
-                if (gi.Name.Contains("("))
-                {
-                    gi.Name = gi.Name.Substring(0, gi.Name.IndexOf("(")).Trim();
-                }
-
-                // remove special characters like dashes
-                gi.Name = gi.Name.Replace("-", "").Trim();
-
-                // get rom data
-                ri.Name = Path.GetFileName(GameFileImportPath);
-                ri.Md5 = hash.md5hash;
-                ri.Sha1 = hash.sha1hash;
-                ri.Size = ImageSize;
-                ri.SignatureSource = gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType.None;
-
-                return discoveredSignature;
-            }
-        }
-
-        public class ArchiveData
-        {
-            public string FileName { get; set; }
-            public string FilePath { get; set; }
-            public long Size { get; set; }
-            public string MD5 { get; set; }
-            public string SHA1 { get; set; }
-        }
-    }
-}

gaseous-server/Classes/Filters.cs

@@ -1,143 +0,0 @@
-using System.Data;
-using System.Reflection.Metadata.Ecma335;
-using gaseous_server.Classes.Metadata;
-using IGDB.Models;
-
-namespace gaseous_server.Classes
-{
-    public class Filters
-    {
-        public static Dictionary<string, List<FilterItem>> Filter(Metadata.AgeGroups.AgeRestrictionGroupings MaximumAgeRestriction, bool IncludeUnrated)
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-            Dictionary<string, List<FilterItem>> FilterSet = new Dictionary<string, List<FilterItem>>();
-
-            // platforms
-            List<FilterItem> platforms = new List<FilterItem>();
-            
-            string ageRestriction_Platform = "AgeGroup.AgeGroupId <= " + (int)MaximumAgeRestriction;
-            string ageRestriction_Generic = "view_Games.AgeGroupId <= " + (int)MaximumAgeRestriction;
-            if (IncludeUnrated == true)
-            {
-                ageRestriction_Platform += " OR AgeGroup.AgeGroupId IS NULL";
-                ageRestriction_Generic += " OR view_Games.AgeGroupId IS NULL";
-            }
-
-            string sql = "SELECT Platform.Id, Platform.`Name`, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, Games_Roms.PlatformId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + ageRestriction_Platform + ") GROUP BY Game.Id , Games_Roms.PlatformId HAVING RomCount > 0) Game JOIN Platform ON Game.PlatformId = Platform.Id GROUP BY Platform.`Name`;";
-            
-            DataTable dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                FilterItem platformItem = new FilterItem(dr);
-                platforms.Add(platformItem);
-
-            }
-            FilterSet.Add("platforms", platforms);
-
-            // genres
-            List<FilterItem> genres = new List<FilterItem>();
-            dbResponse = GetGenericFilterItem(db, "Genre", ageRestriction_Platform);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                FilterItem genreItem = new FilterItem(dr);
-                genres.Add(genreItem);
-            }
-            FilterSet.Add("genres", genres);
-
-            // game modes
-            List<FilterItem> gameModes = new List<FilterItem>();
-            dbResponse = GetGenericFilterItem(db, "GameMode", ageRestriction_Platform);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                FilterItem gameModeItem = new FilterItem(dr);
-                gameModes.Add(gameModeItem);
-            }
-            FilterSet.Add("gamemodes", gameModes);
-
-            // player perspectives
-            List<FilterItem> playerPerspectives = new List<FilterItem>();
-            dbResponse = GetGenericFilterItem(db, "PlayerPerspective", ageRestriction_Platform);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                FilterItem playerPerspectiveItem = new FilterItem(dr);
-                playerPerspectives.Add(playerPerspectiveItem);
-            }
-            FilterSet.Add("playerperspectives", playerPerspectives);
-
-            // themes
-            List<FilterItem> themes = new List<FilterItem>();
-            dbResponse = GetGenericFilterItem(db, "Theme", ageRestriction_Platform);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                FilterItem themeItem = new FilterItem(dr);
-                themes.Add(themeItem);
-            }
-            FilterSet.Add("themes", themes);
-
-            // age groups
-            List<FilterItem> agegroupings = new List<FilterItem>();
-            sql = "SELECT Game.AgeGroupId, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, AgeGroup.AgeGroupId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + ageRestriction_Platform + ") GROUP BY Game.Id HAVING RomCount > 0) Game GROUP BY Game.AgeGroupId ORDER BY Game.AgeGroupId DESC";
-            dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                FilterItem filterAgeGrouping = new FilterItem();
-                if (dr["AgeGroupId"] == DBNull.Value)
-                {
-                    filterAgeGrouping.Id = (int)(long)AgeGroups.AgeRestrictionGroupings.Unclassified;
-                    filterAgeGrouping.Name = AgeGroups.AgeRestrictionGroupings.Unclassified.ToString();
-                }
-                else
-                {
-                    int ageGroupLong = (int)dr["AgeGroupId"];
-                    AgeGroups.AgeRestrictionGroupings ageGroup = (AgeGroups.AgeRestrictionGroupings)ageGroupLong;
-                    filterAgeGrouping.Id = ageGroupLong;
-                    filterAgeGrouping.Name = ageGroup.ToString();
-                }
-                filterAgeGrouping.GameCount = (int)(long)dr["GameCount"];
-                agegroupings.Add(filterAgeGrouping);
-            }
-            FilterSet.Add("agegroupings", agegroupings);
-
-            return FilterSet;
-        }
-
-        private static DataTable GetGenericFilterItem(Database db, string Name, string AgeRestriction)
-        {
-            //string sql = "SELECT DISTINCT <ITEMNAME>.Id, <ITEMNAME>.`Name`, COUNT(view_Games.Id) AS GameCount FROM <ITEMNAME> LEFT JOIN Relation_Game_<ITEMNAME>s ON Relation_Game_<ITEMNAME>s.<ITEMNAME>sId = <ITEMNAME>.Id LEFT JOIN view_Games ON view_Games.Id = Relation_Game_<ITEMNAME>s.GameId WHERE (" + AgeRestriction_Generic + ") GROUP BY <ITEMNAME>.Id HAVING GameCount > 0 ORDER BY <ITEMNAME>.`Name`;";
-
-            string sql = "SELECT <ITEMNAME>.Id, <ITEMNAME>.`Name`, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, AgeGroup.AgeGroupId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + AgeRestriction + ") GROUP BY Game.Id HAVING RomCount > 0) Game JOIN Relation_Game_<ITEMNAME>s ON Game.Id = Relation_Game_<ITEMNAME>s.GameId JOIN <ITEMNAME> ON Relation_Game_<ITEMNAME>s.<ITEMNAME>sId = <ITEMNAME>.Id GROUP BY <ITEMNAME>.`Name` ORDER BY <ITEMNAME>.`Name`;";
-            sql = sql.Replace("<ITEMNAME>", Name);
-            DataTable dbResponse = db.ExecuteCMD(sql);
-
-            return dbResponse;
-        }
-
-        public class FilterItem
-        {
-            public FilterItem()
-            {
-
-            }
-
-            public FilterItem(DataRow dr)
-            {
-                this.Id = (long)dr["Id"];
-                this.Name = (string)dr["Name"];
-                this.GameCount = (int)(long)dr["GameCount"];
-            }
-
-            public long Id { get; set; }
-
-            public string Name { get; set; }
-
-            public int GameCount { get; set; }
-        }
-    }
-}