WIP

Resolve some issues with how the new UI renders.

.devcontainer/.env

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

.devcontainer/Dockerfile

@@ -1,6 +1,10 @@
 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
+# update apt-get
+RUN apt-get update
+
+# download and unzip EmulatorJS from CDN
+RUN apt-get install -y p7zip-full default-jdk nodejs wget
+RUN mkdir -p out/wwwroot/emulators/EmulatorJS
+RUN wget https://cdn.emulatorjs.org/releases/4.1.1.7z
+RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.1.1.7z

.devcontainer/devcontainer.json

@@ -1,27 +1,25 @@
 // 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)",
+	"name": "Gaseous 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],
+	"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": {
@@ -36,11 +34,14 @@
 				"AndersEAndersen.html-class-suggestions",
 				"george-alisson.html-preview-vscode",
 				"ms-dotnettools.vscodeintellicode-csharp",
-				"Zignd.html-css-class-completion"
+				"Zignd.html-css-class-completion",
+				"PWABuilder.pwa-studio",
+				"ms-azuretools.vscode-docker",
+				"SonarSource.sonarlint-vscode",
+				"oderwat.indent-rainbow"
 			]
 		}
 	}
-
 	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
 	// "remoteUser": "root"
 }

.devcontainer/docker-compose.yml

@@ -11,11 +11,13 @@ services:
       - dbhost=${DATABASE_HOST}
       - dbuser=${DATABASE_USER}
       - dbpass=${DATABASE_PASSWORD}
-      - igdbclientid=<clientid>
-      - igdbclientsecret=<clientsecret>
+      - igdbclientid=${IGDB_CLIENT_ID}
+      - igdbclientsecret=${IGDB_CLIENT_SECRET}
   mariadb:
     hostname: mariadb
     image: mariadb:latest
+    ports:
+      - 3306:3306
     environment:
       - MARIADB_ROOT_PASSWORD=${DATABASE_PASSWORD}
       - MARIADB_DATABASE=${DATABASE_DB}

.github/workflows/BuildDockerOnTag-Prerelease.yml

@@ -9,9 +9,14 @@ on:
 jobs:
   docker:
     runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+      attestations: write
+      id-token: write
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           submodules: 'true'
       - name: Install dotnet tool
@@ -21,18 +26,37 @@ 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@v2
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
       - name: Login to Docker Hub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v4
+      - name: Login to GitHub Package Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push standard image
+        uses: docker/build-push-action@v6
         with:
           context: .
+          file: ./build/Dockerfile
           platforms: linux/amd64,linux/arm64
           push: true
-          tags: gaseousgames/gaseousserver:${{ github.ref_name}}
+          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

.github/workflows/BuildDockerOnTag-Release.yml

@@ -8,9 +8,14 @@ on:
 jobs:
   docker:
     runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+      attestations: write
+      id-token: write
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           submodules: 'true'
       - name: Install dotnet tool
@@ -20,18 +25,39 @@ 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@v2
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
       - name: Login to Docker Hub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Build and push
-        uses: docker/build-push-action@v4
+      - name: Login to GitHub Package Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push standard image
+        uses: docker/build-push-action@v6
         with:
           context: .
+          file: ./build/Dockerfile
           platforms: linux/amd64,linux/arm64
           push: true
-          tags: gaseousgames/gaseousserver:latest,gaseousgames/gaseousserver:${{ github.ref_name}}
+          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:${{ github.ref_name}}-embeddeddb
+            ghcr.io/gaseous-project/gaseousserver:${{ github.ref_name}}-embeddeddb

.github/workflows/BuildNightly.yml

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

.github/workflows/codeql.yml

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

.gitignore

@@ -404,4 +404,7 @@ ASALocalRun/
 # Local History for Visual Studio
 .localhistory/
 gaseous-server/.DS_Store
+gaseous-server/wwwroot/.DS_Store
 gaseous-server/wwwroot/emulators/EmulatorJS
+.devcontainer/.env
+.mono/

.vscode/launch.json

@@ -24,7 +24,8 @@
             },
             "sourceFileMap": {
                 "/Views": "${workspaceFolder}/Views"
-            }
+            },
+            "enableStepFiltering": false
         },
         {
             "name": ".NET Core Attach",

Dockerfile

@@ -1,28 +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
-
-# download and unzip EmulatorJS from CDN
-RUN apt-get update && apt-get install -y p7zip-full
-RUN mkdir -p out/wwwroot/emulators/EmulatorJS
-RUN wget https://cdn.emulatorjs.org/releases/4.0.11.7z
-RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.0.11.7z
-
-# Build runtime image
-FROM mcr.microsoft.com/dotnet/aspnet:8.0
-ENV INDOCKER=1
-WORKDIR /App
-COPY --from=build-env /App/out .
-ENTRYPOINT ["dotnet", "gaseous-server.dll"]

Gaseous.sln

@@ -1,4 +1,4 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 25.0.1704.4
@@ -21,36 +21,30 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "screenshots", "screenshots"
 		screenshots\Game.png = screenshots\Game.png
 	EndProjectSection
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-cli", "gaseous-cli\gaseous-cli.csproj", "{419CC4E4-8932-4E4A-B027-5521AA0CBA85}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{08699C93-15CD-4E39-9053-D3C8056CE938}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.Build.0 = Release|Any CPU
 		{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
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	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
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {979BF092-AFBC-4F19-B55F-32E73959BD1A}
+	EndGlobalSection
 EndGlobal

LICENSE

@@ -1,5 +1,5 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
@@ -7,17 +7,15 @@
 
                             Preamble
 
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
+  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 licenses for most software and other practical works are designed
 to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
+our General Public Licenses are 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.  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.
+software for all its users.
 
   When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
@@ -26,44 +24,34 @@ 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.
 
-  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.
+  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.
 
-  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.
+  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.
 
-  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.
+  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.
 
-  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.
+  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.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
@@ -72,7 +60,7 @@ modification follow.
 
   0. Definitions.
 
-  "This License" refers to version 3 of the GNU General Public License.
+  "This License" refers to version 3 of the GNU Affero General Public License.
 
   "Copyright" also means copyright-like laws that apply to other kinds of
 works, such as semiconductor masks.
@@ -549,35 +537,45 @@ 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. Use with the GNU Affero General Public License.
+  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.
 
   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 Affero General Public License into a single
+under version 3 of the GNU 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 special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
 
   14. Revised Versions of this License.
 
   The Free Software Foundation may publish revised and/or new versions of
-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
+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
 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 General
+Program specifies that a certain numbered version of the GNU Affero 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 General Public License, you may choose any version ever published
+GNU Affero 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 General Public License can be used, that proxy's
+versions of the GNU Affero 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.
 
@@ -631,44 +629,33 @@ 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.
 
-    Gaseous
-    Copyright (C) 2023  Gaseous
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
 
     This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
+    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
     (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 General Public License for more details.
+    GNU Affero General Public License for more details.
 
-    You should have received a copy of the GNU General Public License
+    You should have received a copy of the GNU Affero 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 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".
+  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.
 
   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 GPL, see
+For more information on this, and how to apply and follow the GNU AGPL, 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,34 +1,30 @@
-[![.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
+[![.NET](https://github.com/gaseous-project/gaseous-server/actions/workflows/dotnet.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/dotnet.yml) [![Nightly](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildNightly.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildNightly.yml) [![Build Release Docker Image](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildDockerOnTag-Release.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildDockerOnTag-Release.yml)
+# <img src="./logo.png" height="28" style="float: right;" /> Gaseous Server
 
 This is the server for the Gaseous system. It offers ROM and title management, as well as some basic in browser emulation of those ROMs.
 
-## 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
-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.
+Version 1.7.0 and later contain user authentication, and can be exposed to the internet. However, it is recommended to not expose the server to the internet if you're not actively using it remotely, or if you have alternative means to access it remotely like a VPN.
 
 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**.
 
 ## Screenshots
-![Library](./screenshots/Library.png)
-![Game](./screenshots/Game.png)
-![Emulator](./screenshots/Emulator.png)
-
+![Library](./gaseous-server/wwwroot/screenshots/Library.png)
+![Game](./gaseous-server/wwwroot/screenshots/Game.png)
+![Emulator](./gaseous-server/wwwroot/screenshots/Emulator.png)
 
 ## Requirements
-* MariaDB 11.1.2 (preferred) or MySQL Server 8+
+* 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.
 * 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.
+# Installation
+See https://github.com/gaseous-project/gaseous-server/wiki/Installation for installation instructions.
+
+# Adding Content
+1. Import signatures: see https://github.com/gaseous-project/gaseous-server/wiki/Signatures
+2. Add ROMs: see https://github.com/gaseous-project/gaseous-server/wiki/Adding-ROMs
 
 ## Friends of Gaseous
 * [EmulatorJS](https://github.com/EmulatorJS/EmulatorJS): A fantastic (and fast) Javascript based implementation of RetroArch, supporting a wide variety of platforms. Discord: https://discord.gg/6akryGkETU
@@ -43,11 +39,4 @@ The following projects are used by Gaseous
 * [EmulatorJS](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.
-
-# 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
+Join our Discord server: https://discord.gg/Nhu7wpT3k4

build/Dockerfile

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

build/Dockerfile-EmbeddedDB

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

build/embeddeddb/entrypoint.sh

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

build/embeddeddb/mariadb.sh

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

build/embeddeddb/supervisord.conf

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

build/standard/entrypoint.sh

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

build/standard/supervisord.conf

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

docker-compose-build.yml

@@ -4,6 +4,7 @@ services:
     container_name: gaseous-server
     build:
       context: ./
+      dockerfile: ./build/Dockerfile
     restart: unless-stopped
     networks:
       - gaseous
@@ -12,7 +13,7 @@ services:
     ports:
       - 5198:80
     volumes:
-      - gs:/root/.gaseous-server
+      - gs:/home/gaseous/.gaseous-server
     environment:
       - TZ=Australia/Sydney
       - dbhost=gsdb

docker-compose.yml

@@ -1,39 +0,0 @@
-version: '2'
-services:
-  gaseous-server:
-    container_name: gaseous-server
-    image: gaseousgames/gaseousserver:latest
-    restart: unless-stopped
-    networks:
-      - gaseous
-    depends_on:
-      - gsdb
-    ports:
-      - 5198:80
-    volumes:
-      - gs:/root/.gaseous-server
-    environment:
-      - TZ=Australia/Sydney
-      - dbhost=gsdb
-      - dbuser=root
-      - dbpass=gaseous
-      - igdbclientid=<clientid>
-      - igdbclientsecret=<clientsecret>
-  gsdb:
-    container_name: gsdb
-    image: mariadb
-    restart: unless-stopped
-    networks:
-      - gaseous
-    volumes:
-      - gsdb:/var/lib/mysql
-    environment:
-      - MARIADB_ROOT_PASSWORD=gaseous
-      - MARIADB_USER=gaseous
-      - MARIADB_PASSWORD=gaseous
-networks:
-  gaseous:
-    driver: bridge
-volumes:
-  gs:
-  gsdb:

gaseous-cli/Program.cs

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

gaseous-cli/gaseous-cli.csproj

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

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

@@ -12,6 +12,6 @@ namespace Authentication
     {
         public SecurityProfileViewModel SecurityProfile { get; set; }
         public List<UserPreferenceViewModel> UserPreferences { get; set; }
-        public Guid Avatar { get; set; }
+        public Guid ProfileId { get; set; }
     }
 }

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

@@ -75,7 +75,7 @@ namespace Authentication
         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";
+            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId where Id = @id";
             Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@id", userId } };
 
             var rows = _database.ExecuteCMDDict(commandText, parameters);
@@ -100,7 +100,7 @@ namespace Authentication
                 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"]);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
             }
 
             return user;
@@ -114,7 +114,7 @@ namespace Authentication
         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";
+            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId where NormalizedEmail = @name";
             Dictionary<string, object> parameters = new Dictionary<string, object>() { { "@name", normalizedUserName } };
 
             var rows = _database.ExecuteCMDDict(commandText, parameters);
@@ -138,7 +138,7 @@ namespace Authentication
                 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"]);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
                 users.Add(user);
             }
 
@@ -148,7 +148,7 @@ namespace Authentication
         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";
+            string commandText = "Select * from Users LEFT JOIN (SELECT Id As ProfileId, UserId FROM UserProfiles) UserProfiles ON Users.Id = UserProfiles.UserId order by NormalizedUserName";
 
             var rows = _database.ExecuteCMDDict(commandText);
             foreach (Dictionary<string, object> row in rows)
@@ -171,7 +171,7 @@ namespace Authentication
                 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"]);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
                 users.Add(user);
             }
 
@@ -258,10 +258,11 @@ namespace Authentication
         /// <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);";
+            string commandText = @"Insert into Users (UserName, Id, PasswordHash, SecurityStamp, ConcurrencyStamp, Email, EmailConfirmed, PhoneNumber, PhoneNumberConfirmed, NormalizedEmail, NormalizedUserName, AccessFailedCount, LockoutEnabled, LockoutEnd, TwoFactorEnabled) values (@name, @id, @pwdHash, @SecStamp, @concurrencystamp, @email ,@emailconfirmed ,@phonenumber, @phonenumberconfirmed, @normalizedemail, @normalizedusername, @accesscount, @lockoutenabled, @lockoutenddate, @twofactorenabled); Insert into UserProfiles (Id, UserId, DisplayName, Quip, UnstructuredData) values (@profileId, @id, @email, '', '{}');";
             Dictionary<string, object> parameters = new Dictionary<string, object>();
             parameters.Add("@name", user.UserName);
             parameters.Add("@id", user.Id);
+            parameters.Add("@profileId", Guid.NewGuid());
             parameters.Add("@pwdHash", user.PasswordHash);
             parameters.Add("@SecStamp", user.SecurityStamp);
             parameters.Add("@concurrencystamp", user.ConcurrencyStamp);
@@ -292,7 +293,7 @@ namespace Authentication
         /// <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;";
+            string commandText = "Delete from Users where Id = @userId; Delete from User_Settings where Id = @userId; Delete from UserProfiles where UserId = @userId; Delete from GameState where UserId = @userId;";
             Dictionary<string, object> parameters = new Dictionary<string, object>();
             parameters.Add("@userId", userId);
 

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

@@ -8,8 +8,9 @@ namespace Authentication
         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 {
+        public Guid ProfileId { get; set; }
+        public string HighestRole
+        {
             get
             {
                 string _highestRole = "";

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

@@ -8,11 +8,14 @@ namespace Authentication
         public DateTimeOffset? LockoutEnd { get; set; }
         public List<string> Roles { get; set; }
         public SecurityProfileViewModel SecurityProfile { get; set; }
-        public Guid Avatar { get; set; }
-        public string HighestRole {
+        public Guid ProfileId { get; set; }
+        public string HighestRole
+        {
             get
             {
                 string _highestRole = "";
+                if (Roles != null)
+                {
                     foreach (string role in Roles)
                     {
                         switch (role)
@@ -40,6 +43,11 @@ namespace Authentication
                                 break;
                         }
                     }
+                }
+                else
+                {
+                    _highestRole = "Player";
+                }
 
                 return _highestRole;
             }

gaseous-server/Classes/Bios.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
+using gaseous_server.Classes.Metadata;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes
 {
@@ -11,6 +13,64 @@ namespace gaseous_server.Classes
 
         }
 
+        public static void ImportBiosFile(string FilePath, Common.hashObject Hash, ref Dictionary<string, object> BiosFileInfo)
+        {
+            BiosFileInfo.Add("type", "bios");
+            BiosFileInfo.Add("status", "notimported");
+
+            foreach (Classes.Bios.BiosItem biosItem in Classes.Bios.GetBios())
+            {
+                if (biosItem.Available == false)
+                {
+                    if (biosItem.hash == Hash.md5hash)
+                    {
+                        string biosPath = Path.Combine(Config.LibraryConfiguration.LibraryFirmwareDirectory, biosItem.hash + ".bios");
+                        Logging.Log(Logging.LogType.Information, "Import BIOS File", "  " + FilePath + " is a BIOS file - moving to " + biosPath);
+
+                        File.Move(FilePath, biosItem.biosPath, true);
+
+                        BiosFileInfo.Add("name", biosItem.filename);
+                        BiosFileInfo.Add("platform", Platforms.GetPlatform(biosItem.platformid));
+                        BiosFileInfo["status"] = "imported";
+                    }
+                }
+                else
+                {
+                    if (biosItem.hash == Hash.md5hash)
+                    {
+                        BiosFileInfo["status"] = "duplicate";
+                    }
+                }
+            }
+        }
+
+        public static void MigrateToNewFolderStructure()
+        {
+            // migrate from old BIOS file structure which had each bios file inside a folder named for the platform to the new structure which has each file in a subdirectory named after the MD5 hash
+            if (Directory.Exists(Config.LibraryConfiguration.LibraryBIOSDirectory))
+            {
+                foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
+                {
+                    if (platformMapping.Bios != null)
+                    {
+                        foreach (Models.PlatformMapping.PlatformMapItem.EmulatorBiosItem emulatorBiosItem in platformMapping.Bios)
+                        {
+                            string oldBiosPath = Path.Combine(Config.LibraryConfiguration.LibraryBIOSDirectory, platformMapping.IGDBSlug.ToString(), emulatorBiosItem.filename);
+                            string newBiosPath = Path.Combine(Config.LibraryConfiguration.LibraryFirmwareDirectory, emulatorBiosItem.hash + ".bios");
+
+                            if (File.Exists(oldBiosPath))
+                            {
+                                File.Copy(oldBiosPath, newBiosPath, true);
+                            }
+                        }
+                    }
+                }
+
+                // remove old BIOS folder structure
+                Directory.Delete(Config.LibraryConfiguration.LibraryBIOSDirectory, true);
+            }
+        }
+
         public static Models.PlatformMapping.PlatformMapItem? BiosHashSignatureLookup(string MD5)
         {
             foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
@@ -67,7 +127,7 @@ namespace gaseous_server.Classes
             {
                 if (platformMapping.Bios != null)
                 {
-                    IGDB.Models.Platform platform = Metadata.Platforms.GetPlatform(platformMapping.IGDBId);
+                    Platform platform = Metadata.Platforms.GetPlatform(platformMapping.IGDBId);
 
                     foreach (Models.PlatformMapping.PlatformMapItem.EmulatorBiosItem emulatorBios in platformMapping.Bios)
                     {
@@ -96,10 +156,11 @@ namespace gaseous_server.Classes
             {
                 get
                 {
-                    return Path.Combine(Config.LibraryConfiguration.LibraryBIOSDirectory, platformslug, base.filename);
+                    return Path.Combine(Config.LibraryConfiguration.LibraryFirmwareDirectory, hash + ".bios");
                 }
             }
-            public bool Available {
+            public bool Available
+            {
                 get
                 {
                     bool fileExists = File.Exists(biosPath);

gaseous-server/Classes/Collections.cs

@@ -9,7 +9,7 @@ using gaseous_server.Classes.Metadata;
 using gaseous_server.Controllers;
 using gaseous_server.Controllers.v1_1;
 using gaseous_server.Models;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc.Filters;
 using Newtonsoft.Json;
@@ -20,7 +20,8 @@ namespace gaseous_server.Classes
 {
     public class Collections
     {
-        public static List<CollectionItem> GetCollections(string userid) {
+        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>{
@@ -30,14 +31,16 @@ namespace gaseous_server.Classes
 
             List<CollectionItem> collectionItems = new List<CollectionItem>();
 
-            foreach(DataRow row in data.Rows) {
+            foreach (DataRow row in data.Rows)
+            {
                 collectionItems.Add(BuildCollectionItem(row));
             }
 
             return collectionItems;
         }
 
-        public static CollectionItem GetCollection(long Id, string userid) {
+        public static CollectionItem GetCollection(long Id, string userid)
+        {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql;
             if (userid == "")
@@ -208,7 +211,8 @@ namespace gaseous_server.Classes
             }
         }
 
-        public static CollectionContents GetCollectionContent(CollectionItem collectionItem, string userid) {
+        public static CollectionContents GetCollectionContent(CollectionItem collectionItem, string userid)
+        {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
             // get age ratings for specified user
@@ -260,15 +264,20 @@ namespace gaseous_server.Classes
             }
 
             // add dynamic platforms
-            if (DynamicPlatforms.Count > 0) {
-                foreach (long PlatformId in platformids) {
+            if (DynamicPlatforms.Count > 0)
+            {
+                foreach (long PlatformId in platformids)
+                {
                     platforms.Add(Platforms.GetPlatform(PlatformId));
                 }
-            } else {
+            }
+            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) {
+                foreach (Filters.FilterItem filterItem in filteredPlatforms)
+                {
                     platforms.Add(Platforms.GetPlatform(filterItem.Id));
                 }
             }
@@ -280,7 +289,8 @@ namespace gaseous_server.Classes
             // build collection
             List<CollectionContents.CollectionPlatformItem> platformItems = new List<CollectionContents.CollectionPlatformItem>();
 
-            foreach (Platform platform in platforms) {
+            foreach (Platform platform in platforms)
+            {
                 long TotalRomSize = 0;
                 long TotalGameCount = 0;
 
@@ -297,7 +307,8 @@ namespace gaseous_server.Classes
                 Controllers.v1_1.GamesController.GameReturnPackage games = new Controllers.v1_1.GamesController.GameReturnPackage();
                 if (isDynamic == true)
                 {
-                    Controllers.v1_1.GamesController.GameSearchModel searchModel = new Controllers.v1_1.GamesController.GameSearchModel{
+                    Controllers.v1_1.GamesController.GameSearchModel searchModel = new Controllers.v1_1.GamesController.GameSearchModel
+                    {
                         Name = "",
                         Platform = new List<string>{
                             platform.Id.ToString()
@@ -306,11 +317,13 @@ namespace gaseous_server.Classes
                         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{
+                        GameRating = new Controllers.v1_1.GamesController.GameSearchModel.GameRatingItem
+                        {
                             MinimumRating = collectionItem.MinimumRating,
                             MaximumRating = collectionItem.MaximumRating
                         },
-                        GameAgeRating = new Controllers.v1_1.GamesController.GameSearchModel.GameAgeRatingItem{
+                        GameAgeRating = new Controllers.v1_1.GamesController.GameSearchModel.GameAgeRatingItem
+                        {
                             AgeGroupings = UserAgeGroupings,
                             IncludeUnrated = UserAgeGroupIncludeUnrated
                         }
@@ -332,7 +345,7 @@ namespace gaseous_server.Classes
                         ) && alwaysIncludeItem.PlatformId == platform.Id
                         )
                     {
-                            MinimalGameItem AlwaysIncludeGame = new MinimalGameItem(Games.GetGame(alwaysIncludeItem.GameId, false, false, false));
+                        MinimalGameItem AlwaysIncludeGame = new MinimalGameItem(Games.GetGame(HasheousClient.Models.MetadataSources.IGDB, alwaysIncludeItem.GameId));
                         CollectionContents.CollectionPlatformItem.CollectionGameItem gameItem = new CollectionContents.CollectionPlatformItem.CollectionGameItem(AlwaysIncludeGame);
                         gameItem.InclusionStatus = new CollectionItem.AlwaysIncludeItem();
                         gameItem.InclusionStatus.PlatformId = alwaysIncludeItem.PlatformId;
@@ -344,7 +357,8 @@ namespace gaseous_server.Classes
                     }
                 }
 
-                foreach (MinimalGameItem game in games.Games) {
+                foreach (MinimalGameItem game in games.Games)
+                {
                     bool gameAlreadyInList = false;
                     foreach (CollectionContents.CollectionPlatformItem.CollectionGameItem existingGame in collectionPlatformItem.Games)
                     {
@@ -364,11 +378,14 @@ namespace gaseous_server.Classes
 
                         // calculate total rom size for the game
                         long GameRomSize = 0;
-                        foreach (Roms.GameRomItem gameRom in gameRoms) {
+                        foreach (Roms.GameRomItem gameRom in gameRoms)
+                        {
                             GameRomSize += (long)gameRom.Size;
                         }
-                        if (collectionItem.MaximumBytesPerPlatform > 0) {
-                            if ((TotalRomSize + GameRomSize) < collectionItem.MaximumBytesPerPlatform) {
+                        if (collectionItem.MaximumBytesPerPlatform > 0)
+                        {
+                            if ((TotalRomSize + GameRomSize) < collectionItem.MaximumBytesPerPlatform)
+                            {
                                 AddGame = true;
                             }
                         }
@@ -377,13 +394,16 @@ namespace gaseous_server.Classes
                             AddGame = true;
                         }
 
-                        if (AddGame == true) {
+                        if (AddGame == true)
+                        {
                             TotalRomSize += GameRomSize;
 
                             bool AddRoms = false;
 
-                            if (collectionItem.MaximumRomsPerPlatform > 0) { 
-                                if (TotalGameCount < collectionItem.MaximumRomsPerPlatform) {
+                            if (collectionItem.MaximumRomsPerPlatform > 0)
+                            {
+                                if (TotalGameCount < collectionItem.MaximumRomsPerPlatform)
+                                {
                                     AddRoms = true;
                                 }
                             }
@@ -392,7 +412,8 @@ namespace gaseous_server.Classes
                                 AddRoms = true;
                             }
 
-                            if (AddRoms == true) {
+                            if (AddRoms == true)
+                            {
                                 TotalGameCount += 1;
                                 collectionGameItem.Roms = gameRoms;
                                 collectionPlatformItem.Games.Add(collectionGameItem);
@@ -401,7 +422,8 @@ namespace gaseous_server.Classes
                     }
 
                     // handle age grouping
-                    AgeGroups.AgeRestrictionGroupings CurrentAgeGroup = AgeGroups.GetAgeGroupFromAgeRatings(game.AgeRatings);
+                    List<AgeRating> gameAgeRatings = game.AgeRatings.Select(s => (AgeRating)s).ToList();
+                    AgeGroups.AgeRestrictionGroupings CurrentAgeGroup = AgeGroups.GetAgeGroupFromAgeRatings(gameAgeRatings);
                     if (CurrentAgeGroup > AgeGrouping)
                     {
                         AgeGrouping = CurrentAgeGroup;
@@ -500,7 +522,8 @@ namespace gaseous_server.Classes
                         if (collectionItem.IncludeBIOSFiles == true)
                         {
                             List<Bios.BiosItem> bios = Bios.GetBios(collectionPlatformItem.Id, true);
-                            if (!Directory.Exists(ZipBiosPath)) {
+                            if (!Directory.Exists(ZipBiosPath))
+                            {
                                 Directory.CreateDirectory(ZipBiosPath);
                             }
 
@@ -639,7 +662,8 @@ namespace gaseous_server.Classes
             }
         }
 
-        private static CollectionItem BuildCollectionItem(DataRow row) {
+        private static CollectionItem BuildCollectionItem(DataRow row)
+        {
             string strPlatforms = (string)Common.ReturnValueIfNull(row["Platforms"], "[ ]");
             string strGenres = (string)Common.ReturnValueIfNull(row["Genres"], "[ ]");
             string strPlayers = (string)Common.ReturnValueIfNull(row["Players"], "[ ]");
@@ -810,7 +834,8 @@ namespace gaseous_server.Classes
             }
         }
 
-        public class CollectionContents {
+        public class CollectionContents
+        {
             [JsonIgnore]
             public List<CollectionPlatformItem> Collection { get; set; }
 
@@ -840,13 +865,16 @@ namespace gaseous_server.Classes
             public AgeGroups.AgeRestrictionGroupings AgeGroup { get; set; }
             public bool ContainsUnclassifiedAgeGroup { get; set; }
 
-            public class CollectionPlatformItem {
-                public CollectionPlatformItem(IGDB.Models.Platform platform) {
+            public class CollectionPlatformItem
+            {
+                public CollectionPlatformItem(Platform platform)
+                {
                     string[] PropertyWhitelist = new string[] { "Id", "Name", "Slug" };
 
-                    PropertyInfo[] srcProperties = typeof(IGDB.Models.Platform).GetProperties();
+                    PropertyInfo[] srcProperties = typeof(Platform).GetProperties();
                     PropertyInfo[] dstProperties = typeof(CollectionPlatformItem).GetProperties();
-                    foreach (PropertyInfo srcProperty in srcProperties) {
+                    foreach (PropertyInfo srcProperty in srcProperties)
+                    {
                         if (PropertyWhitelist.Contains<string>(srcProperty.Name))
                         {
                             foreach (PropertyInfo dstProperty in dstProperties)
@@ -866,10 +894,13 @@ namespace gaseous_server.Classes
 
                 public List<CollectionGameItem> Games { get; set; }
 
-                public int RomCount {
-                    get {
+                public int RomCount
+                {
+                    get
+                    {
                         int Counter = 0;
-                        foreach (CollectionGameItem Game in Games) {
+                        foreach (CollectionGameItem Game in Games)
+                        {
                             Counter += 1;
                         }
 
@@ -877,11 +908,15 @@ namespace gaseous_server.Classes
                     }
                 }
 
-                public long RomSize {
-                    get {
+                public long RomSize
+                {
+                    get
+                    {
                         long Size = 0;
-                        foreach (CollectionGameItem Game in Games) {
-                            foreach (Roms.GameRomItem Rom in Game.Roms) {
+                        foreach (CollectionGameItem Game in Games)
+                        {
+                            foreach (Roms.GameRomItem Rom in Game.Roms)
+                            {
                                 Size += (long)Rom.Size;
                             }
                         }
@@ -905,28 +940,12 @@ namespace gaseous_server.Classes
                         this.AgeRatings = gameObject.AgeRatings;
                     }
 
-                    public IGDB.Models.Cover? CoverItem
-                    {
-                        get
-                        {
-                            if (Cover != null)
-                            {
-                                IGDB.Models.Cover cover = Covers.GetCover(Cover.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory, "Games", Slug), false);
-
-                                return cover;
-                            }
-                            else
-                            {
-                                return null;
-                            }
-                        }
-                    }
-
                     public AgeGroups.AgeRestrictionGroupings AgeGrouping
                     {
                         get
                         {
-                            return AgeGroups.GetAgeGroupFromAgeRatings(this.AgeRatings);
+                            List<AgeRating> gameAgeRatings = this.AgeRatings.Select(s => (AgeRating)s).ToList();
+                            return AgeGroups.GetAgeGroupFromAgeRatings(gameAgeRatings);
                         }
                     }
 
@@ -934,10 +953,13 @@ namespace gaseous_server.Classes
 
                     public List<Roms.GameRomItem> Roms { get; set; }
 
-                    public long RomSize {
-                    get {
+                    public long RomSize
+                    {
+                        get
+                        {
                             long Size = 0;
-                        foreach (Roms.GameRomItem Rom in Roms) {
+                            foreach (Roms.GameRomItem Rom in Roms)
+                            {
                                 Size += (long)Rom.Size;
                             }
 

gaseous-server/Classes/Common.cs

@@ -1,8 +1,11 @@
 using System.Collections.Concurrent;
 using System.ComponentModel;
+using System.Data;
+using System.Drawing;
 using System.IO.Compression;
 using System.Reflection;
 using System.Security.Cryptography;
+using static gaseous_server.Classes.Metadata.Communications;
 
 namespace gaseous_server.Classes
 {
@@ -19,7 +22,8 @@ namespace gaseous_server.Classes
 			if (ObjectToCheck == null || ObjectToCheck == System.DBNull.Value)
 			{
 				return IfNullValue;
-			} else
+			}
+			else
 			{
 				return ObjectToCheck;
 			}
@@ -43,11 +47,13 @@ namespace gaseous_server.Classes
 			{
 				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);
@@ -122,6 +128,27 @@ namespace gaseous_server.Classes
 				typeof(DescriptionAttribute)))?.Description ?? value.ToString();
 		}
 
+		public static Point GetResolution(this Enum value)
+		{
+			string width = ((ResolutionAttribute)Attribute.GetCustomAttribute(
+				value.GetType().GetFields(BindingFlags.Public | BindingFlags.Static)
+					.Single(x => x.GetValue(null).Equals(value)),
+				typeof(ResolutionAttribute)))?.width.ToString() ?? value.ToString();
+
+			string height = ((ResolutionAttribute)Attribute.GetCustomAttribute(
+			value.GetType().GetFields(BindingFlags.Public | BindingFlags.Static)
+				.Single(x => x.GetValue(null).Equals(value)),
+			typeof(ResolutionAttribute)))?.height.ToString() ?? value.ToString();
+
+			return new Point(int.Parse(width), int.Parse(height));
+		}
+
+		public static bool IsNullableEnum(this Type t)
+		{
+			Type u = Nullable.GetUnderlyingType(t);
+			return u != null && u.IsEnum;
+		}
+
 		// compression
 		public static byte[] Compress(byte[] data)
 		{
@@ -155,6 +182,50 @@ namespace gaseous_server.Classes
 				return defaultValue;
 			}
 		}
+
+		public static int GetLookupByCode(LookupTypes LookupType, string Code)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT Id FROM " + LookupType.ToString() + " WHERE Code = @code";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>{
+				{ "code", Code }
+			};
+
+			DataTable data = db.ExecuteCMD(sql, dbDict);
+			if (data.Rows.Count == 0)
+			{
+				return -1;
+			}
+			else
+			{
+				return (int)data.Rows[0]["Id"];
+			}
+		}
+
+		public static int GetLookupByValue(LookupTypes LookupType, string Value)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT Id FROM " + LookupType.ToString() + " WHERE Value = @value";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>{
+				{ "value", Value }
+			};
+
+			DataTable data = db.ExecuteCMD(sql, dbDict);
+			if (data.Rows.Count == 0)
+			{
+				return -1;
+			}
+			else
+			{
+				return (int)data.Rows[0]["Id"];
+			}
+		}
+
+		public enum LookupTypes
+		{
+			Country,
+			Language
+		}
 	}
 
 	/// <summary>

gaseous-server/Classes/Config.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Data;
 using Newtonsoft.Json;
-using IGDB.Models;
 using gaseous_server.Classes.Metadata;
 using NuGet.Common;
 
@@ -80,7 +79,8 @@ namespace gaseous_server.Classes
             get
             {
                 string logPath = Path.Combine(ConfigurationPath, "Logs");
-                if (!Directory.Exists(logPath)) {
+                if (!Directory.Exists(logPath))
+                {
                     Directory.CreateDirectory(logPath);
                 }
                 return logPath;
@@ -114,7 +114,12 @@ namespace gaseous_server.Classes
                 if (File.Exists(ConfigurationFilePath))
                 {
                     string configRaw = File.ReadAllText(ConfigurationFilePath);
-                    ConfigFile? _tempConfig = Newtonsoft.Json.JsonConvert.DeserializeObject<ConfigFile>(configRaw);
+                    Newtonsoft.Json.JsonSerializerSettings serializerSettings = new Newtonsoft.Json.JsonSerializerSettings
+                    {
+                        NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
+                        MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore
+                    };
+                    ConfigFile? _tempConfig = Newtonsoft.Json.JsonConvert.DeserializeObject<ConfigFile>(configRaw, serializerSettings);
                     if (_tempConfig != null)
                     {
                         _config = _tempConfig;
@@ -130,9 +135,9 @@ namespace gaseous_server.Classes
                                 _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.DefaultMetadataSource = (HasheousClient.Models.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataSources), (string)Common.GetEnvVar("metadatasource", _config.MetadataConfiguration.DefaultMetadataSource.ToString()));
+                                _config.IGDBConfiguration.UseHasheousProxy = bool.Parse((string)Common.GetEnvVar("metadatausehasheousproxy", _config.IGDBConfiguration.UseHasheousProxy.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);
@@ -153,8 +158,8 @@ namespace gaseous_server.Classes
                 }
             }
 
-            Console.WriteLine("Using configuration:");
-            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(_config, Formatting.Indented));
+            // Console.WriteLine("Using configuration:");
+            // Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(_config, Formatting.Indented));
         }
 
         public static void UpdateConfig()
@@ -201,7 +206,7 @@ namespace gaseous_server.Classes
                     AppSettings.Remove(SettingName);
                 }
 
-                Logging.Log(Logging.LogType.Information, "Load Settings", "Loading setting " + SettingName + " from database");
+                // Logging.Log(Logging.LogType.Information, "Load Settings", "Loading setting " + SettingName + " from database");
 
                 try
                 {
@@ -422,7 +427,8 @@ namespace gaseous_server.Classes
 
             public class Database
             {
-                private static string _DefaultHostName {
+                private static string _DefaultHostName
+                {
                     get
                     {
                         if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbhost")))
@@ -529,11 +535,7 @@ namespace gaseous_server.Classes
                 {
                     get
                     {
-                        return ReadSetting<string>("LibraryRootDirectory", Path.Combine(Config.ConfigurationPath, "Data"));
-                    }
-                    set
-                    {
-                        SetSetting<string>("LibraryRootDirectory", value);
+                        return Path.Combine(Config.ConfigurationPath, "Data");
                     }
                 }
 
@@ -577,6 +579,14 @@ namespace gaseous_server.Classes
                     }
                 }
 
+                public string LibraryFirmwareDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryRootDirectory, "Firmware");
+                    }
+                }
+
                 public string LibraryUploadDirectory
                 {
                     get
@@ -617,28 +627,35 @@ namespace gaseous_server.Classes
                     }
                 }
 
-                public string LibraryMetadataDirectory_Platform(Platform platform)
+                public string LibraryMetadataDirectory_Platform(HasheousClient.Models.Metadata.IGDB.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)
+                public string LibraryMetadataDirectory_Game(gaseous_server.Models.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)
+                public string LibraryMetadataDirectory_Company(HasheousClient.Models.Metadata.IGDB.Company company)
                 {
                     string MetadataPath = Path.Combine(LibraryMetadataDirectory, "Companies", company.Slug);
                     if (!Directory.Exists(MetadataPath)) { Directory.CreateDirectory(MetadataPath); }
                     return MetadataPath;
                 }
 
-                public string LibrarySignatureImportDirectory
+                public string LibraryMetadataDirectory_Hasheous()
+                {
+                    string MetadataPath = Path.Combine(LibraryMetadataDirectory, "Hasheous");
+                    if (!Directory.Exists(MetadataPath)) { Directory.CreateDirectory(MetadataPath); }
+                    return MetadataPath;
+                }
+
+                public string LibrarySignaturesDirectory
                 {
                     get
                     {
@@ -646,32 +663,64 @@ namespace gaseous_server.Classes
                     }
                 }
 
+                public string LibrarySignaturesProcessedDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryRootDirectory, "Signatures - Processed");
+                    }
+                }
+
                 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(LibraryFirmwareDirectory)) { Directory.CreateDirectory(LibraryFirmwareDirectory); }
                     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); }
+                    if (!Directory.Exists(LibrarySignaturesDirectory)) { Directory.CreateDirectory(LibrarySignaturesDirectory); }
+                    if (!Directory.Exists(LibrarySignaturesProcessedDirectory)) { Directory.CreateDirectory(LibrarySignaturesProcessedDirectory); }
                 }
             }
 
             public class MetadataAPI
             {
-                private static HasheousClient.Models.MetadataModel.MetadataSources _MetadataSource
+                public static string _HasheousClientAPIKey
+                {
+                    get
+                    {
+                        return "Pna5SRcbJ6R8aasytab_6vZD0aBKDGNZKRz4WY4xArpfZ-3mdZq0hXIGyy0AD43b";
+                    }
+                }
+
+                private static HasheousClient.Models.MetadataSources _MetadataSource
                 {
                     get
                     {
                         if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("metadatasource")))
                         {
-                            return (HasheousClient.Models.MetadataModel.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.MetadataSources), Environment.GetEnvironmentVariable("metadatasource"));
+                            return (HasheousClient.Models.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataSources), Environment.GetEnvironmentVariable("metadatasource"));
                         }
                         else
                         {
-                            return HasheousClient.Models.MetadataModel.MetadataSources.IGDB;
+                            return HasheousClient.Models.MetadataSources.IGDB;
+                        }
+                    }
+                }
+
+                private static bool _MetadataUseHasheousProxy
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("metadatausehasheousproxy")))
+                        {
+                            return bool.Parse(Environment.GetEnvironmentVariable("metadatausehasheousproxy"));
+                        }
+                        else
+                        {
+                            return true;
                         }
                     }
                 }
@@ -691,20 +740,9 @@ namespace gaseous_server.Classes
                     }
                 }
 
-                private static int _MaxLibraryScanWorkers
-                {
-                    get
-                    {
-                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("maxlibraryscanworkers")))
-                        {
-                            return int.Parse(Environment.GetEnvironmentVariable("maxlibraryscanworkers"));
-                        }
-                        else
-                        {
-                            return 4;
-                        }
-                    }
-                }
+                private static bool _HasheousSubmitFixes { get; set; } = false;
+
+                private static string _HasheousAPIKey { get; set; } = "";
 
                 private static string _HasheousHost
                 {
@@ -721,11 +759,16 @@ namespace gaseous_server.Classes
                     }
                 }
 
-                public HasheousClient.Models.MetadataModel.MetadataSources MetadataSource = _MetadataSource;
+                public HasheousClient.Models.MetadataSources DefaultMetadataSource = _MetadataSource;
 
                 public HasheousClient.Models.MetadataModel.SignatureSources SignatureSource = _SignatureSource;
 
-                public int MaxLibraryScanWorkers = _MaxLibraryScanWorkers;
+                public bool HasheousSubmitFixes = _HasheousSubmitFixes;
+
+                public string HasheousAPIKey = _HasheousAPIKey;
+
+                [JsonIgnore]
+                public string HasheousClientAPIKey = _HasheousClientAPIKey;
 
                 public string HasheousHost = _HasheousHost;
             }
@@ -762,8 +805,24 @@ namespace gaseous_server.Classes
                     }
                 }
 
+                private static bool _MetadataUseHasheousProxy
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("igdbusehasheousproxy")))
+                        {
+                            return bool.Parse(Environment.GetEnvironmentVariable("igdbusehasheousproxy"));
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                    }
+                }
+
                 public string ClientId = _DefaultIGDBClientId;
                 public string Secret = _DefaultIGDBSecret;
+                public bool UseHasheousProxy = _MetadataUseHasheousProxy;
             }
 
             public class Logging

gaseous-server/Classes/Database.cs

@@ -9,7 +9,20 @@ namespace gaseous_server.Classes
 {
 	public class Database
 	{
-		public static int schema_version = 0;
+		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()
 		{
@@ -60,6 +73,8 @@ namespace gaseous_server.Classes
 			// load resources
 			var assembly = Assembly.GetExecutingAssembly();
 
+			DatabaseMemoryCacheOptions? CacheOptions = new DatabaseMemoryCacheOptions(false);
+
 			switch (_ConnectorType)
 			{
 				case databaseType.MySql:
@@ -67,20 +82,29 @@ namespace gaseous_server.Classes
 					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);
+					ExecuteCMD(sql, dbDict, CacheOptions, 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);
+					DataTable SchemaVersionPresent = ExecuteCMD(sql, dbDict, CacheOptions);
 					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);
+						ExecuteCMD(sql, dbDict, CacheOptions);
 					}
 
-                    for (int i = 1000; i < 10000; i++)
+					sql = "SELECT schema_version FROM schema_version;";
+					dbDict = new Dictionary<string, object>();
+					DataTable SchemaVersion = ExecuteCMD(sql, dbDict, CacheOptions);
+					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 = "";
@@ -96,7 +120,7 @@ namespace gaseous_server.Classes
 								// apply script
 								sql = "SELECT schema_version FROM schema_version;";
 								dbDict = new Dictionary<string, object>();
-								DataTable SchemaVersion = ExecuteCMD(sql, dbDict);
+								SchemaVersion = ExecuteCMD(sql, dbDict, CacheOptions);
 								if (SchemaVersion.Rows.Count == 0)
 								{
 									// something is broken here... where's the table?
@@ -107,6 +131,8 @@ namespace gaseous_server.Classes
 								{
 									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
@@ -116,12 +142,12 @@ namespace gaseous_server.Classes
 
 											// apply schema!
 											Logging.Log(Logging.LogType.Information, "Database", "Updating schema to version " + i);
-											ExecuteCMD(dbScript, dbDict, 180);
+											ExecuteCMD(dbScript, dbDict, CacheOptions, 180);
 
 											sql = "UPDATE schema_version SET schema_version=@schemaver";
 											dbDict = new Dictionary<string, object>();
 											dbDict.Add("schemaver", i);
-											ExecuteCMD(sql, dbDict);
+											ExecuteCMD(sql, dbDict, CacheOptions);
 
 											// run post-upgrade code
 											DatabaseMigration.PostUpgradeScript(i, _ConnectorType);
@@ -146,39 +172,83 @@ namespace gaseous_server.Classes
 
 		public DataTable ExecuteCMD(string Command)
 		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			return _ExecuteCMD(Command, dbDict, 30, "");
+			return _ExecuteCMD(Command, dbDict, CacheOptions, 30, "");
+		}
+
+		public DataTable ExecuteCMD(string Command, DatabaseMemoryCacheOptions? CacheOptions)
+		{
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			return _ExecuteCMD(Command, dbDict, CacheOptions, 30, "");
 		}
 
 		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters)
 		{
-            return _ExecuteCMD(Command, Parameters, 30, "");
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMD(Command, Parameters, CacheOptions, 30, "");
+		}
+
+		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions)
+		{
+			return _ExecuteCMD(Command, Parameters, CacheOptions, 30, "");
 		}
 
 		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
 		{
-			return _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMD(Command, Parameters, CacheOptions, Timeout, ConnectionString);
+		}
+
+		public DataTable ExecuteCMD(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
+		{
+			return _ExecuteCMD(Command, Parameters, CacheOptions, Timeout, ConnectionString);
 		}
 
 		public List<Dictionary<string, object>> ExecuteCMDDict(string Command)
 		{
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			return _ExecuteCMDDict(Command, dbDict, 30, "");
+			return _ExecuteCMDDict(Command, dbDict, CacheOptions, 30, "");
+		}
+
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, DatabaseMemoryCacheOptions? CacheOptions)
+		{
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			return _ExecuteCMDDict(Command, dbDict, CacheOptions, 30, "");
 		}
 
 		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters)
 		{
-            return _ExecuteCMDDict(Command, Parameters, 30, "");
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, 30, "");
+		}
+
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions)
+		{
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, 30, "");
 		}
 
 		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
 		{
-			return _ExecuteCMDDict(Command, Parameters, Timeout, ConnectionString);
+			DatabaseMemoryCacheOptions? CacheOptions = null;
+
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, Timeout, ConnectionString);
 		}
 
-		private List<Dictionary<string, object>> _ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
 		{
-			DataTable dataTable = _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
+			return _ExecuteCMDDict(Command, Parameters, CacheOptions, Timeout, ConnectionString);
+		}
+
+		private List<Dictionary<string, object>> _ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
+		{
+			DataTable dataTable = _ExecuteCMD(Command, Parameters, CacheOptions, Timeout, ConnectionString);
 
 			// convert datatable to dictionary
 			List<Dictionary<string, object?>> rows = new List<Dictionary<string, object?>>();
@@ -204,14 +274,45 @@ namespace gaseous_server.Classes
 			return rows;
 		}
 
-        private DataTable _ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		private DataTable _ExecuteCMD(string Command, Dictionary<string, object> Parameters, DatabaseMemoryCacheOptions? CacheOptions, int Timeout = 30, string ConnectionString = "")
 		{
+			string CacheKey = Command + string.Join(";", Parameters.Select(x => string.Join("=", x.Key, x.Value)));
+
+			if (CacheOptions is object && CacheOptions.CacheEnabled)
+			{
+				object? CachedData = DatabaseMemoryCache.GetCacheObject(CacheKey);
+				if (CachedData is object)
+				{
+					return (DataTable)CachedData;
+				}
+			}
+
+			// purge cache if command contains "INSERT", "UPDATE", "DELETE", or "ALTER"
+			if (
+				Command.Contains("INSERT", StringComparison.InvariantCultureIgnoreCase) ||
+				Command.Contains("UPDATE", StringComparison.InvariantCultureIgnoreCase) ||
+				Command.Contains("DELETE", StringComparison.InvariantCultureIgnoreCase) ||
+				Command.Contains("ALTER", StringComparison.InvariantCultureIgnoreCase)
+				)
+			{
+				// exclude logging events from purging the cache
+				if (!Command.StartsWith("INSERT INTO SERVERLOGS", StringComparison.InvariantCultureIgnoreCase))
+				{
+					DatabaseMemoryCache.ClearCache();
+				}
+			}
+
 			if (ConnectionString == "") { ConnectionString = _ConnectionString; }
 			switch (_ConnectorType)
 			{
 				case databaseType.MySql:
 					MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
-                    return (DataTable)conn.ExecCMD(Command, Parameters, Timeout);
+					DataTable RetTable = conn.ExecCMD(Command, Parameters, Timeout);
+					if (CacheOptions is object && CacheOptions.CacheEnabled)
+					{
+						DatabaseMemoryCache.SetCacheObject(CacheKey, RetTable, CacheOptions.ExpirationSeconds);
+					}
+					return RetTable;
 				default:
 					return new DataTable();
 			}
@@ -270,6 +371,148 @@ namespace gaseous_server.Classes
 			}
 		}
 
+		public static class DatabaseMemoryCache
+		{
+			private class MemoryCacheItem
+			{
+				public MemoryCacheItem(object CacheObject)
+				{
+					cacheObject = CacheObject;
+				}
+
+				public MemoryCacheItem(object CacheObject, int ExpirationSeconds)
+				{
+					cacheObject = CacheObject;
+					expirationSeconds = ExpirationSeconds;
+				}
+
+				/// <summary>
+				/// The time the object was added to the cache in ticks
+				/// </summary>
+				public long addedTime { get; } = Environment.TickCount64;
+
+				/// <summary>
+				/// The time the object will expire in ticks
+				/// </summary>
+				public long expirationTime
+				{
+					get
+					{
+						return addedTime + _expirationTicks;
+					}
+				}
+
+				/// <summary>
+				/// The number of seconds the object will be cached
+				/// </summary>
+				public int expirationSeconds
+				{
+					get
+					{
+						return (int)TimeSpan.FromTicks(_expirationTicks).Seconds;
+					}
+					set
+					{
+						_expirationTicks = (long)TimeSpan.FromSeconds(value).Ticks;
+					}
+				}
+
+				private long _expirationTicks = (long)TimeSpan.FromSeconds(2).Ticks;
+
+				/// <summary>
+				/// The object to be cached
+				/// </summary>
+				public object cacheObject { get; set; }
+			}
+			private static Dictionary<string, MemoryCacheItem> MemoryCache = new Dictionary<string, MemoryCacheItem>();
+			private static Timer CacheTimer = new Timer(CacheTimerCallback, null, 0, 1000);
+
+			private static void CacheTimerCallback(object? state)
+			{
+				ClearExpiredCache();
+			}
+
+			public static object? GetCacheObject(string CacheKey)
+			{
+				if (MemoryCache.ContainsKey(CacheKey))
+				{
+					if (MemoryCache[CacheKey].expirationTime < Environment.TickCount)
+					{
+						MemoryCache.Remove(CacheKey);
+						return null;
+					}
+					else
+					{
+						return MemoryCache[CacheKey].cacheObject;
+					}
+				}
+				else
+				{
+					return null;
+				}
+			}
+			public static void SetCacheObject(string CacheKey, object CacheObject, int ExpirationSeconds = 2)
+			{
+				try
+				{
+					if (MemoryCache.ContainsKey(CacheKey))
+					{
+						MemoryCache.Remove(CacheKey);
+					}
+					MemoryCache.Add(CacheKey, new MemoryCacheItem(CacheObject, ExpirationSeconds));
+				}
+				catch (Exception ex)
+				{
+					Logging.Log(Logging.LogType.Debug, "Database", "Error while setting cache object", ex);
+					ClearCache();
+				}
+			}
+			public static void RemoveCacheObject(string CacheKey)
+			{
+				if (MemoryCache.ContainsKey(CacheKey))
+				{
+					MemoryCache.Remove(CacheKey);
+				}
+			}
+			public static void ClearCache()
+			{
+				MemoryCache.Clear();
+			}
+			private static void ClearExpiredCache()
+			{
+				try
+				{
+					long currTime = Environment.TickCount64;
+
+					Dictionary<string, MemoryCacheItem> ExpiredItems = MemoryCache;
+					foreach (string key in ExpiredItems.Keys)
+					{
+						if (MemoryCache[key].expirationTime < currTime)
+						{
+							Console.WriteLine("\x1b[95mPurging expired cache item " + key + ". Added: " + MemoryCache[key].addedTime + ". Expired: " + MemoryCache[key].expirationTime);
+							MemoryCache.Remove(key);
+						}
+					}
+				}
+				catch (Exception ex)
+				{
+					Logging.Log(Logging.LogType.Debug, "Database", "Error while clearing expired cache", ex);
+				}
+			}
+		}
+
+		public class DatabaseMemoryCacheOptions
+		{
+			public DatabaseMemoryCacheOptions(bool CacheEnabled = false, int ExpirationSeconds = 1)
+			{
+				this.CacheEnabled = CacheEnabled;
+				this.ExpirationSeconds = ExpirationSeconds;
+			}
+
+			public bool CacheEnabled { get; set; }
+			public int ExpirationSeconds { get; set; }
+		}
+
 		public int GetDatabaseSchemaVersion()
 		{
 			switch (_ConnectorType)
@@ -360,7 +603,9 @@ namespace gaseous_server.Classes
 							Logging.Log(Logging.LogType.Debug, "Database", "Parameters: " + dictValues, null, true);
 						}
 						RetTable.Load(cmd.ExecuteReader());
-					} catch (Exception ex) {
+					}
+					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());
@@ -403,7 +648,9 @@ namespace gaseous_server.Classes
 							Logging.Log(Logging.LogType.Debug, "Database", "Parameters: " + dictValues, null, true);
 						}
 						result = cmd.ExecuteNonQuery();
-					} catch (Exception ex) {
+					}
+					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());

gaseous-server/Classes/DatabaseMigration.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Data;
 using System.Reflection;
+using gaseous_server.Classes.Metadata;
+using gaseous_server.Models;
 
 namespace gaseous_server.Classes
 {
@@ -64,6 +66,8 @@ namespace gaseous_server.Classes
 
         public static void PostUpgradeScript(int TargetSchemaVersion, Database.databaseType? DatabaseType)
         {
+            var assembly = Assembly.GetExecutingAssembly();
+
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
@@ -103,6 +107,161 @@ namespace gaseous_server.Classes
                             sql = "DELETE FROM Settings WHERE Setting LIKE 'LastRun_%';";
                             db.ExecuteNonQuery(sql);
                             break;
+
+                        case 1023:
+                            // load country list
+                            Logging.Log(Logging.LogType.Information, "Database Upgrade", "Adding country look up table contents");
+
+                            string countryResourceName = "gaseous_server.Support.Country.txt";
+                            using (Stream stream = assembly.GetManifestResourceStream(countryResourceName))
+                            using (StreamReader reader = new StreamReader(stream))
+                            {
+                                do
+                                {
+                                    string[] line = reader.ReadLine().Split("|");
+
+                                    sql = "INSERT INTO Country (Code, Value) VALUES (@code, @value);";
+                                    dbDict = new Dictionary<string, object>{
+                                { "code", line[0] },
+                                { "value", line[1] }
+                            };
+                                    db.ExecuteNonQuery(sql, dbDict);
+                                } while (reader.EndOfStream == false);
+                            }
+
+                            // load language list
+                            Logging.Log(Logging.LogType.Information, "Database Upgrade", "Adding language look up table contents");
+
+                            string languageResourceName = "gaseous_server.Support.Language.txt";
+                            using (Stream stream = assembly.GetManifestResourceStream(languageResourceName))
+                            using (StreamReader reader = new StreamReader(stream))
+                            {
+                                do
+                                {
+                                    string[] line = reader.ReadLine().Split("|");
+
+                                    sql = "INSERT INTO Language (Code, Value) VALUES (@code, @value);";
+                                    dbDict = new Dictionary<string, object>{
+                                { "code", line[0] },
+                                { "value", line[1] }
+                            };
+                                    db.ExecuteNonQuery(sql, dbDict);
+                                } while (reader.EndOfStream == false);
+                            }
+                            break;
+
+                        case 1024:
+                            // create profiles for all existing users
+                            sql = "SELECT * FROM Users;";
+                            data = db.ExecuteCMD(sql);
+                            foreach (DataRow row in data.Rows)
+                            {
+                                // get legacy avatar from UserAvatars table
+                                sql = "SELECT Avatar FROM UserAvatars WHERE UserId = @userid;";
+                                dbDict = new Dictionary<string, object>
+                                {
+                                    { "userid", row["Id"] }
+                                };
+                                DataTable avatarData = db.ExecuteCMD(sql, dbDict);
+
+                                sql = "INSERT INTO UserProfiles (Id, UserId, DisplayName, Quip, Avatar, AvatarExtension, UnstructuredData) VALUES (@id, @userid, @displayname, @quip, @avatar, @avatarextension, @data);";
+                                dbDict = new Dictionary<string, object>
+                                {
+                                    { "id", Guid.NewGuid() },
+                                    { "userid", row["Id"] },
+                                    { "displayname", row["Email"] },
+                                    { "quip", "" },
+                                    { "avatar", avatarData.Rows.Count > 0 ? avatarData.Rows[0]["Avatar"] : null },
+                                    { "avatarextension", avatarData.Rows.Count > 0 ? ".jpg" : null },
+                                    { "data", "{}" }
+                                };
+                                db.ExecuteNonQuery(sql, dbDict);
+                            }
+
+                            // update all rom paths to use the new format
+                            sql = "SELECT * FROM GameLibraries;";
+                            data = db.ExecuteCMD(sql);
+                            foreach (DataRow row in data.Rows)
+                            {
+                                sql = "SELECT * FROM Games_Roms WHERE LibraryId = @libraryid;";
+                                dbDict = new Dictionary<string, object>
+                                {
+                                    { "libraryid", row["Id"] }
+                                };
+                                DataTable romData = db.ExecuteCMD(sql, dbDict);
+
+                                string libraryRootPath = (string)row["Path"];
+                                if (libraryRootPath.EndsWith(Path.DirectorySeparatorChar.ToString()) == false)
+                                {
+                                    libraryRootPath += Path.DirectorySeparatorChar;
+                                }
+
+                                bool GetLastThreeElements = false;
+                                if ((int)row["DefaultLibrary"] == 1)
+                                {
+                                    GetLastThreeElements = true;
+                                }
+
+                                foreach (DataRow romRow in romData.Rows)
+                                {
+                                    string existingPath = (string)romRow["RelativePath"];
+                                    string newPath = "";
+
+                                    if (GetLastThreeElements == true)
+                                    {
+                                        // strip all but the last 3 elements from existingPath separated by directory separator
+                                        // this mode only works for the default library
+                                        string[] pathParts = existingPath.Split(Path.DirectorySeparatorChar);
+                                        if (pathParts.Length > 3)
+                                        {
+                                            newPath = Path.Combine(pathParts[pathParts.Length - 3], pathParts[pathParts.Length - 2], pathParts[pathParts.Length - 1]);
+                                        }
+                                        else
+                                        {
+                                            newPath = existingPath;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        // strip the library root path from the existing path
+                                        if (existingPath.StartsWith(libraryRootPath))
+                                        {
+                                            newPath = existingPath.Substring(libraryRootPath.Length);
+                                        }
+                                        else
+                                        {
+                                            newPath = existingPath;
+                                        }
+                                    }
+
+                                    Logging.Log(Logging.LogType.Information, "Database Upgrade", "Updating ROM path from " + existingPath + " to " + newPath);
+
+                                    sql = "UPDATE Games_Roms SET RelativePath = @newpath WHERE Id = @id;";
+                                    dbDict = new Dictionary<string, object>
+                                    {
+                                        { "newpath", newPath },
+                                        { "id", romRow["Id"] }
+                                    };
+                                    db.ExecuteNonQuery(sql, dbDict);
+                                }
+                            }
+
+                            // get all tables that have the prefix "Relation_" and drop them
+                            sql = "SELECT table_name FROM information_schema.tables WHERE table_schema = @dbname AND table_name LIKE 'Relation_%';";
+                            dbDict = new Dictionary<string, object>
+                            {
+                                { "dbname", Config.DatabaseConfiguration.DatabaseName }
+                            };
+                            data = db.ExecuteCMD(sql, dbDict);
+                            foreach (DataRow row in data.Rows)
+                            {
+                                sql = "DROP TABLE " + (string)row["table_name"] + ";";
+                                db.ExecuteNonQuery(sql);
+                            }
+
+                            // migrating metadata is a safe background task
+                            BackgroundUpgradeTargetSchemaVersions.Add(1024);
+                            break;
                     }
                     break;
             }
@@ -117,11 +276,16 @@ namespace gaseous_server.Classes
                     case 1002:
                         MySql_1002_MigrateMetadataVersion();
                         break;
+
+                    case 1024:
+                        MySql_1024_MigrateMetadataVersion();
+                        break;
                 }
             }
         }
 
-        public static void MySql_1002_MigrateMetadataVersion() {
+        public static void MySql_1002_MigrateMetadataVersion()
+        {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
@@ -216,5 +380,38 @@ namespace gaseous_server.Classes
                 }
             }
         }
+
+        public static void MySql_1024_MigrateMetadataVersion()
+        {
+            FileSignature fileSignature = new FileSignature();
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM view_Games_Roms WHERE RomDataVersion = 1;";
+            DataTable data = db.ExecuteCMD(sql);
+            long count = 1;
+            foreach (DataRow row in data.Rows)
+            {
+                Logging.Log(Logging.LogType.Information, "Database Migration", "Updating ROM table for ROM (" + count + " / " + data.Rows.Count + "): " + (string)row["Name"]);
+
+                GameLibrary.LibraryItem library = GameLibrary.GetLibrary((int)row["LibraryId"]);
+                Common.hashObject hash = new Common.hashObject()
+                {
+                    md5hash = (string)row["MD5"],
+                    sha1hash = (string)row["SHA1"]
+                };
+                Signatures_Games signature = fileSignature.GetFileSignature(
+                    library,
+                    hash,
+                    new FileInfo((string)row["Path"]),
+                    (string)row["Path"]
+                );
+
+                HasheousClient.Models.Metadata.IGDB.Platform platform = Platforms.GetPlatform((long)row["PlatformId"]);
+
+                ImportGame.StoreGame(library, hash, signature, platform, (string)row["Path"], (long)row["Id"]);
+
+                count += 1;
+            }
+        }
     }
 }

gaseous-server/Classes/FileSignature.cs

@@ -1,6 +1,11 @@
 using System.Collections.Concurrent;
+using System.Configuration;
 using System.IO.Compression;
-using HasheousClient.Models;
+using System.Net;
+using gaseous_server.Classes.Metadata;
+using gaseous_server.Models;
+using HasheousClient.Models.Metadata.IGDB;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using NuGet.Common;
 using SevenZip;
 using SharpCompress.Archives;
@@ -110,8 +115,10 @@ namespace gaseous_server.Classes
                     // loop through contents until we find the first signature match
                     List<ArchiveData> archiveFiles = new List<ArchiveData>();
                     bool signatureFound = false;
+                    bool signatureSelectorAlreadyApplied = false;
                     foreach (string file in Directory.GetFiles(ExtractPath, "*.*", SearchOption.AllDirectories))
                     {
+                        bool signatureSelector = false;
                         if (File.Exists(file))
                         {
                             FileInfo zfi = new FileInfo(file);
@@ -121,15 +128,6 @@ namespace gaseous_server.Classes
 
                             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);
@@ -151,15 +149,37 @@ namespace gaseous_server.Classes
                                         discoveredSignature = zDiscoveredSignature;
 
                                         signatureFound = true;
-                                    }
-                                }
+
+                                        if (signatureSelectorAlreadyApplied == false)
+                                        {
+                                            signatureSelector = true;
+                                            signatureSelectorAlreadyApplied = true;
                                         }
                                     }
                                 }
 
-                    discoveredSignature.Rom.Attributes.Add(new KeyValuePair<string, object>(
+                                ArchiveData archiveData = new ArchiveData
+                                {
+                                    FileName = Path.GetFileName(file),
+                                    FilePath = zfi.Directory.FullName.Replace(ExtractPath, ""),
+                                    Size = zfi.Length,
+                                    MD5 = zhash.md5hash,
+                                    SHA1 = zhash.sha1hash,
+                                    isSignatureSelector = signatureSelector
+                                };
+                                archiveFiles.Add(archiveData);
+                            }
+                        }
+                    }
+
+                    if (discoveredSignature.Rom.Attributes == null)
+                    {
+                        discoveredSignature.Rom.Attributes = new Dictionary<string, object>();
+                    }
+
+                    discoveredSignature.Rom.Attributes.Add(
                          "ZipContents", Newtonsoft.Json.JsonConvert.SerializeObject(archiveFiles)
-                    ));
+                    );
                 }
                 catch (Exception ex)
                 {
@@ -167,6 +187,22 @@ namespace gaseous_server.Classes
                 }
             }
 
+            // get discovered platform
+            Platform? determinedPlatform = null;
+            if (library.DefaultPlatformId == null || library.DefaultPlatformId == 0)
+            {
+                determinedPlatform = Metadata.Platforms.GetPlatform((long)discoveredSignature.Flags.PlatformId);
+                if (determinedPlatform == null)
+                {
+                    determinedPlatform = new Platform();
+                }
+            }
+            else
+            {
+                determinedPlatform = Metadata.Platforms.GetPlatform((long)library.DefaultPlatformId);
+                discoveredSignature.MetadataSources.AddPlatform((long)determinedPlatform.Id, determinedPlatform.Name, HasheousClient.Models.MetadataSources.None);
+            }
+
             return discoveredSignature;
         }
 
@@ -175,43 +211,51 @@ namespace gaseous_server.Classes
             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();
+            gaseous_server.Models.Signatures_Games? discoveredSignature = null;
 
-            // do database search first
-            gaseous_server.Models.Signatures_Games? dbSignature = _GetFileSignatureFromDatabase(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
-
-            if (dbSignature != null)
+            // begin signature search
+            switch (Config.MetadataConfiguration.SignatureSource)
             {
-                // local signature found
-                Logging.Log(Logging.LogType.Information, "Import Game", "Signature found in local database for game: " + dbSignature.Game.Name);
-                discoveredSignature = dbSignature;
+                case HasheousClient.Models.MetadataModel.SignatureSources.LocalOnly:
+                    Logging.Log(Logging.LogType.Information, "Import Game", "Hasheous disabled - searching local database only");
+
+                    discoveredSignature = _GetFileSignatureFromDatabase(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
+
+                    break;
+
+                case HasheousClient.Models.MetadataModel.SignatureSources.Hasheous:
+                    Logging.Log(Logging.LogType.Information, "Import Game", "Hasheous enabled - searching Hashesous and then local database if not found");
+
+                    discoveredSignature = _GetFileSignatureFromHasheous(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
+
+                    if (discoveredSignature == null)
+                    {
+                        Logging.Log(Logging.LogType.Information, "Import Game", "Signature not found in Hasheous - checking local database");
+
+                        discoveredSignature = _GetFileSignatureFromDatabase(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
                     }
                     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;
+                        Logging.Log(Logging.LogType.Information, "Import Game", "Signature retrieved from Hasheous for game: " + discoveredSignature.Game.Name);
                     }
-                else
+                    break;
+
+            }
+
+            if (discoveredSignature == null)
             {
                 // 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);
+                Logging.Log(Logging.LogType.Information, "Import Game", "Signature not found in local database or Hasheous (if enabled) - generating from file data");
 
-                    discoveredSignature = dbSignature;
-                }
+                discoveredSignature = _GetFileSignatureFromFileData(hash, ImageName, ImageExtension, ImageSize, GameFileImportPath);
+
+                Logging.Log(Logging.LogType.Information, "Import Game", "Signature generated from provided file for game: " + discoveredSignature.Game.Name);
             }
 
             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 + ")");
+            Logging.Log(Logging.LogType.Information, "Import Game", "  Platform determined to be: " + discoveredSignature.Flags.PlatformName + " (" + discoveredSignature.Flags.PlatformId + ")");
 
             return discoveredSignature;
         }
@@ -264,29 +308,153 @@ namespace gaseous_server.Classes
             if (Config.MetadataConfiguration.SignatureSource == HasheousClient.Models.MetadataModel.SignatureSources.Hasheous)
             {
                 HasheousClient.Hasheous hasheous = new HasheousClient.Hasheous();
-                SignatureLookupItem? HasheousResult = hasheous.RetrieveFromHasheousAsync(new HashLookupModel{
+                Console.WriteLine(HasheousClient.WebApp.HttpHelper.BaseUri);
+                HasheousClient.Models.LookupItemModel? HasheousResult = null;
+                try
+                {
+                    // check the cache first
+                    if (!Directory.Exists(Config.LibraryConfiguration.LibraryMetadataDirectory_Hasheous()))
+                    {
+                        Directory.CreateDirectory(Config.LibraryConfiguration.LibraryMetadataDirectory_Hasheous());
+                    }
+                    // create file name from hash object
+                    string cacheFileName = hash.md5hash + "_" + hash.sha1hash + ".json";
+                    string cacheFilePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Hasheous(), cacheFileName);
+                    // use cache file if it exists and is less than 30 days old, otherwise fetch from hasheous. if the fetch from hasheous is successful, save it to the cache, if it fails, use the cache if it exists even if it's old
+                    if (File.Exists(cacheFilePath))
+                    {
+                        FileInfo cacheFile = new FileInfo(cacheFilePath);
+                        if (cacheFile.LastWriteTimeUtc > DateTime.UtcNow.AddDays(-30))
+                        {
+                            Logging.Log(Logging.LogType.Information, "Get Signature", "Using cached signature from Hasheous");
+                            HasheousResult = Newtonsoft.Json.JsonConvert.DeserializeObject<HasheousClient.Models.LookupItemModel>(File.ReadAllText(cacheFilePath));
+                        }
+                    }
+
+                    try
+                    {
+                        if (HasheousResult == null)
+                        {
+                            // fetch from hasheous
+                            HasheousResult = hasheous.RetrieveFromHasheous(new HasheousClient.Models.HashLookupModel
+                            {
                                 MD5 = hash.md5hash,
                                 SHA1 = hash.sha1hash
                             });
 
+                            if (HasheousResult != null)
+                            {
+                                // save to cache
+                                File.WriteAllText(cacheFilePath, Newtonsoft.Json.JsonConvert.SerializeObject(HasheousResult));
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        if (File.Exists(cacheFilePath))
+                        {
+                            Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous - using cached signature", ex);
+                            HasheousResult = Newtonsoft.Json.JsonConvert.DeserializeObject<HasheousClient.Models.LookupItemModel>(File.ReadAllText(cacheFilePath));
+                        }
+                        else
+                        {
+                            Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
+                        }
+                    }
+
                     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;
+                            string gameJson = Newtonsoft.Json.JsonConvert.SerializeObject(HasheousResult.Signature.Game);
+                            string romJson = Newtonsoft.Json.JsonConvert.SerializeObject(HasheousResult.Signature.Rom);
+                            signature.Game = Newtonsoft.Json.JsonConvert.DeserializeObject<Models.Signatures_Games.GameItem>(gameJson);
+                            signature.Rom = Newtonsoft.Json.JsonConvert.DeserializeObject<Models.Signatures_Games.RomItem>(romJson);
 
-                        if (HasheousResult.MetadataResults != null)
+                            // get platform metadata
+                            if (HasheousResult.Platform != null)
                             {
-                            if (HasheousResult.MetadataResults.Count > 0)
+                                if (HasheousResult.Platform.metadata.Count > 0)
                                 {
-                                foreach (SignatureLookupItem.MetadataResult metadataResult in HasheousResult.MetadataResults)
+                                    foreach (HasheousClient.Models.MetadataItem metadataResult in HasheousResult.Platform.metadata)
                                     {
-                                    if (metadataResult.Source == MetadataModel.MetadataSources.IGDB)
+                                        // only IGDB metadata is supported
+                                        if (metadataResult.Source == HasheousClient.Models.MetadataSources.IGDB)
                                         {
-                                        signature.Flags.IGDBPlatformId = (long)metadataResult.PlatformId;
-                                        signature.Flags.IGDBGameId = (long)metadataResult.GameId;
+                                            if (metadataResult.ImmutableId.Length > 0)
+                                            {
+                                                // use immutable id
+                                                Platform hasheousPlatform = Platforms.GetPlatform(long.Parse(metadataResult.ImmutableId));
+                                                signature.MetadataSources.AddPlatform((long)hasheousPlatform.Id, hasheousPlatform.Name, metadataResult.Source);
+                                            }
+                                            else if (metadataResult.Id.Length > 0)
+                                            {
+                                                // fall back to id
+                                                Platform hasheousPlatform = Platforms.GetPlatform(metadataResult.Id);
+                                                signature.MetadataSources.AddPlatform((long)hasheousPlatform.Id, hasheousPlatform.Name, metadataResult.Source);
+                                            }
+                                            else
+                                            {
+                                                // no id or immutable id - use unknown platform
+                                                signature.MetadataSources.AddPlatform(0, "Unknown Platform", HasheousClient.Models.MetadataSources.None);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            // get game metadata
+                            if (HasheousResult.Metadata != null)
+                            {
+                                if (HasheousResult.Metadata.Count > 0)
+                                {
+                                    foreach (HasheousClient.Models.MetadataItem metadataResult in HasheousResult.Metadata)
+                                    {
+                                        if (metadataResult.ImmutableId.Length > 0)
+                                        {
+                                            signature.MetadataSources.AddGame(long.Parse(metadataResult.ImmutableId), HasheousResult.Name, metadataResult.Source);
+                                        }
+                                        else if (metadataResult.Id.Length > 0)
+                                        {
+                                            switch (metadataResult.Source)
+                                            {
+                                                case HasheousClient.Models.MetadataSources.IGDB:
+                                                    gaseous_server.Models.Game hasheousGame = Games.GetGame(HasheousClient.Models.MetadataSources.IGDB, metadataResult.Id);
+                                                    signature.MetadataSources.AddGame((long)hasheousGame.Id, hasheousGame.Name, metadataResult.Source);
+                                                    break;
+
+                                                default:
+                                                    if (long.TryParse(metadataResult.Id, out long id) == true)
+                                                    {
+                                                        signature.MetadataSources.AddGame(id, HasheousResult.Name, metadataResult.Source);
+                                                    }
+                                                    else
+                                                    {
+                                                        signature.MetadataSources.AddGame(0, "Unknown Game", HasheousClient.Models.MetadataSources.None);
+                                                    }
+                                                    break;
+                                            }
+                                        }
+                                        else
+                                        {
+                                            // no id or immutable id - use unknown game
+                                            signature.MetadataSources.AddGame(0, "Unknown Game", HasheousClient.Models.MetadataSources.None);
+                                        }
+                                    }
+                                }
+                            }
+
+                            // check attributes for a user manual link
+                            if (HasheousResult.Attributes != null)
+                            {
+                                if (HasheousResult.Attributes.Count > 0)
+                                {
+                                    foreach (HasheousClient.Models.AttributeItem attribute in HasheousResult.Attributes)
+                                    {
+                                        if (attribute.attributeName == HasheousClient.Models.AttributeItem.AttributeName.VIMMManualId)
+                                        {
+                                            signature.Game.UserManual = attribute.GetType().GetProperty("Link").GetValue(attribute).ToString();
                                         }
                                     }
                                 }
@@ -296,6 +464,36 @@ namespace gaseous_server.Classes
                         }
                     }
                 }
+                catch (AggregateException aggEx)
+                {
+                    foreach (Exception ex in aggEx.InnerExceptions)
+                    {
+                        // get exception type
+                        if (ex is HttpRequestException)
+                        {
+                            if (ex.Message.Contains("404 (Not Found)"))
+                            {
+                                Logging.Log(Logging.LogType.Information, "Get Signature", "No signature found in Hasheous");
+                            }
+                            else
+                            {
+                                Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
+                                throw;
+                            }
+                        }
+                        else
+                        {
+                            Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
+                            throw;
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Get Signature", "Error retrieving signature from Hasheous", ex);
+                    throw;
+                }
+            }
 
             return null;
         }
@@ -368,6 +566,7 @@ namespace gaseous_server.Classes
             public long Size { get; set; }
             public string MD5 { get; set; }
             public string SHA1 { get; set; }
+            public bool isSignatureSelector { get; set; } = false;
         }
     }
 }

gaseous-server/Classes/Filters.cs

@@ -24,9 +24,9 @@ namespace gaseous_server.Classes
                 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`;";
+            string sql = "SELECT Platform.Id, Platform.`Name`, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, view_Games_Roms.PlatformId, COUNT(view_Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN view_Games_Roms ON Game.Id = view_Games_Roms.GameId WHERE (" + ageRestriction_Platform + ") GROUP BY Game.Id , view_Games_Roms.PlatformId HAVING RomCount > 0) Game JOIN Platform ON Game.PlatformId = Platform.Id AND Platform.SourceId = 0 GROUP BY Platform.`Name`;";
 
-            DataTable dbResponse = db.ExecuteCMD(sql);
+            DataTable dbResponse = db.ExecuteCMD(sql, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 300));
 
             foreach (DataRow dr in dbResponse.Rows)
             {
@@ -82,8 +82,8 @@ namespace gaseous_server.Classes
 
             // 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);
+            sql = "SELECT Game.AgeGroupId, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, AgeGroup.AgeGroupId, COUNT(view_Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN view_Games_Roms ON Game.Id = view_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, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 300));
 
             foreach (DataRow dr in dbResponse.Rows)
             {
@@ -112,9 +112,9 @@ namespace gaseous_server.Classes
         {
             //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`;";
+            string sql = "SELECT <ITEMNAME>.Id, <ITEMNAME>.`Name`, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT view_Games_Roms.GameIdType, Game.Id, AgeGroup.AgeGroupId, COUNT(view_Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN view_Games_Roms ON Game.Id = view_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 AND Game.GameIdType = Relation_Game_<ITEMNAME>s.GameSourceId 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);
+            DataTable dbResponse = db.ExecuteCMD(sql, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 300));
 
             return dbResponse;
         }

gaseous-server/Classes/GameLibrary.cs

@@ -2,7 +2,6 @@ using System;
 using System.Data;
 using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
-using IGDB.Models;
 using Microsoft.CodeAnalysis.FlowAnalysis.DataFlow;
 
 namespace gaseous_server
@@ -60,13 +59,25 @@ namespace gaseous_server
             }
         }
 
+        // update default library path
+        public static void UpdateDefaultLibraryPath()
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "UPDATE GameLibraries SET Path=@path WHERE DefaultLibrary=1;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "path", Path.Combine(Config.LibraryConfiguration.LibraryRootDirectory, "Library") }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
         public static List<LibraryItem> GetLibraries
         {
             get
             {
                 List<LibraryItem> libraryItems = new List<LibraryItem>();
                 Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-                string sql = "SELECT * FROM GameLibraries";
+                string sql = "SELECT * FROM GameLibraries ORDER BY `Name`;";
                 DataTable data = db.ExecuteCMD(sql);
                 foreach (DataRow row in data.Rows)
                 {
@@ -175,6 +186,24 @@ namespace gaseous_server
             }
         }
 
+        public static LibraryItem ScanLibrary(int LibraryId)
+        {
+            // add the library to scan to the queue
+            LibraryItem library = GetLibrary(LibraryId);
+            ImportGame.LibrariesToScan.Add(library);
+
+            // start the library scan if it's not already running
+            foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+            {
+                if (item.ItemType == ProcessQueue.QueueItemType.LibraryScan && item.ItemState != ProcessQueue.QueueItemState.Running)
+                {
+                    item.ForceExecute();
+                }
+            }
+
+            return library;
+        }
+
         public class LibraryItem
         {
             public LibraryItem(int Id, string Name, string Path, long DefaultPlatformId, bool IsDefaultLibrary)
@@ -207,7 +236,7 @@ namespace gaseous_server
                 {
                     if (_DefaultPlatformId != 0)
                     {
-                        Platform platform = Platforms.GetPlatform(_DefaultPlatformId);
+                        HasheousClient.Models.Metadata.IGDB.Platform platform = Platforms.GetPlatform(_DefaultPlatformId);
                         return platform.Name;
                     }
                     else

gaseous-server/Classes/ImportGames.cs

@@ -7,17 +7,26 @@ using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using gaseous_server.Classes.Metadata;
 using gaseous_server.Models;
-using IGDB.Models;
 using NuGet.Common;
 using NuGet.LibraryModel;
 using static gaseous_server.Classes.Metadata.Games;
 using static gaseous_server.Classes.FileSignature;
 using HasheousClient.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes
 {
     public class ImportGame : QueueItemStatus
     {
+        /// <summary>
+        /// Scan the import directory for games and process them
+        /// </summary>
+        /// <param name="ImportPath">
+        /// The path to the directory to scan
+        /// </param>
+        /// <exception cref="DirectoryNotFoundException">
+        /// Thrown when the import directory does not exist
+        /// </exception>
         public void ProcessDirectory(string ImportPath)
         {
             if (Directory.Exists(ImportPath))
@@ -28,7 +37,8 @@ namespace gaseous_server.Classes
 
                 // import files first
                 int importCount = 1;
-				foreach (string importContent in importContents) {
+                foreach (string importContent in importContents)
+                {
                     SetStatus(importCount, importContents.Length, "Importing file: " + importContent);
 
                     ImportGameFile(importContent, null);
@@ -46,11 +56,22 @@ namespace gaseous_server.Classes
             }
         }
 
-        public void ImportGameFile(string GameFileImportPath, IGDB.Models.Platform? OverridePlatform)
+        /// <summary>
+        /// Import a single game file
+        /// </summary>
+        /// <param name="GameFileImportPath">
+        /// The path to the game file to import
+        /// </param>
+        /// <param name="OverridePlatform">
+        /// The platform to use for the game file
+        /// </param>
+        /// <returns>
+        /// A dictionary containing the results of the import
+        /// </returns>
+        public Dictionary<string, object> ImportGameFile(string GameFileImportPath, Platform? OverridePlatform)
         {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql = "";
-			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            Dictionary<string, object> RetVal = new Dictionary<string, object>();
+            RetVal.Add("path", Path.GetFileName(GameFileImportPath));
 
             if (Common.SkippableFiles.Contains<string>(Path.GetFileName(GameFileImportPath), StringComparer.OrdinalIgnoreCase))
             {
@@ -58,7 +79,6 @@ namespace gaseous_server.Classes
             }
             else
             {
-                FileInfo fi = new FileInfo(GameFileImportPath);
                 Common.hashObject hash = new Common.hashObject(GameFileImportPath);
 
                 Models.PlatformMapping.PlatformMapItem? IsBios = Classes.Bios.BiosHashSignatureLookup(hash.md5hash);
@@ -66,99 +86,251 @@ namespace gaseous_server.Classes
                 if (IsBios == null)
                 {
                     // file is a rom
+                    _ImportGameFile(GameFileImportPath, hash, ref RetVal, OverridePlatform);
+                }
+                else
+                {
+                    // file is a bios
+                    Bios.ImportBiosFile(GameFileImportPath, hash, ref RetVal);
+                }
+            }
+
+            return RetVal;
+        }
+
+        /// <summary>
+        /// Import a single game file
+        /// </summary>
+        /// <param name="FilePath">
+        /// The path to the game file to import
+        /// </param>
+        /// <param name="Hash">
+        /// The hash of the game file
+        /// </param>
+        /// <param name="GameFileInfo">
+        /// A dictionary to store the results of the import
+        /// </param>
+        /// <param name="OverridePlatform">
+        /// The platform to use for the game file
+        /// </param>
+        private static void _ImportGameFile(string FilePath, Common.hashObject Hash, ref Dictionary<string, object> GameFileInfo, Platform? OverridePlatform)
+        {
+            GameFileInfo.Add("type", "rom");
+
             // check to make sure we don't already have this file imported
-                    sql = "SELECT COUNT(Id) AS count FROM Games_Roms WHERE MD5=@md5 AND SHA1=@sha1";
-                    dbDict.Add("md5", hash.md5hash);
-                    dbDict.Add("sha1", hash.sha1hash);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+
+            sql = "SELECT COUNT(Id) AS count FROM view_Games_Roms WHERE MD5=@md5 AND SHA1=@sha1";
+            dbDict.Add("md5", Hash.md5hash);
+            dbDict.Add("sha1", Hash.sha1hash);
             DataTable importDB = db.ExecuteCMD(sql, dbDict);
             if ((Int64)importDB.Rows[0]["count"] > 0)
             {
                 // import source was the import directory
-                        if (GameFileImportPath.StartsWith(Config.LibraryConfiguration.LibraryImportDirectory))
+                if (FilePath.StartsWith(Config.LibraryConfiguration.LibraryImportDirectory))
                 {
-                            Logging.Log(Logging.LogType.Warning, "Import Game", "  " + GameFileImportPath + " already in database - moving to " + Config.LibraryConfiguration.LibraryImportDuplicatesDirectory);
+                    Logging.Log(Logging.LogType.Warning, "Import Game", "  " + FilePath + " already in database - moving to " + Config.LibraryConfiguration.LibraryImportDuplicatesDirectory);
 
-                            string targetPathWithFileName = GameFileImportPath.Replace(Config.LibraryConfiguration.LibraryImportDirectory, Config.LibraryConfiguration.LibraryImportDuplicatesDirectory);
+                    string targetPathWithFileName = FilePath.Replace(Config.LibraryConfiguration.LibraryImportDirectory, Config.LibraryConfiguration.LibraryImportDuplicatesDirectory);
                     string targetPath = Path.GetDirectoryName(targetPathWithFileName);
 
                     if (!Directory.Exists(targetPath))
                     {
                         Directory.CreateDirectory(targetPath);
                     }
-                            File.Move(GameFileImportPath, targetPathWithFileName, true);
+                    File.Move(FilePath, targetPathWithFileName, true);
                 }
 
                 // import source was the upload directory
-                        if (GameFileImportPath.StartsWith(Config.LibraryConfiguration.LibraryUploadDirectory))
+                if (FilePath.StartsWith(Config.LibraryConfiguration.LibraryUploadDirectory))
                 {
-                            Logging.Log(Logging.LogType.Warning, "Import Game", "  " + GameFileImportPath + " already in database - skipping import");
+                    Logging.Log(Logging.LogType.Warning, "Import Game", "  " + FilePath + " already in database - skipping import");
                 }
+
+                GameFileInfo.Add("status", "duplicate");
             }
             else
             {
-                        Logging.Log(Logging.LogType.Information, "Import Game", "  " + GameFileImportPath + " not in database - processing");
+                Logging.Log(Logging.LogType.Information, "Import Game", "  " + FilePath + " not in database - processing");
 
+                FileInfo fi = new FileInfo(FilePath);
                 FileSignature fileSignature = new FileSignature();
-                        gaseous_server.Models.Signatures_Games discoveredSignature = fileSignature.GetFileSignature(GameLibrary.GetDefaultLibrary, hash, fi, GameFileImportPath);
-
-                        // get discovered platform
-                        IGDB.Models.Platform? determinedPlatform = null;
-                        if (OverridePlatform == null)
-                        {
-                            determinedPlatform = Metadata.Platforms.GetPlatform(discoveredSignature.Flags.IGDBPlatformId);
-                            if (determinedPlatform == null)
-                            {
-                                determinedPlatform = new IGDB.Models.Platform();
-                            }
-                        }
-                        else
-                        {
-                            determinedPlatform = OverridePlatform;
-                            discoveredSignature.Flags.IGDBPlatformId = (long)determinedPlatform.Id;
-                            discoveredSignature.Flags.IGDBPlatformName = determinedPlatform.Name;
-                        }
-
-                        IGDB.Models.Game determinedGame = SearchForGame(discoveredSignature, discoveredSignature.Flags.IGDBPlatformId, true);
+                gaseous_server.Models.Signatures_Games discoveredSignature = fileSignature.GetFileSignature(GameLibrary.GetDefaultLibrary, Hash, fi, FilePath);
 
                 // add to database
-                        StoreROM(GameLibrary.GetDefaultLibrary, hash, determinedGame, determinedPlatform, discoveredSignature, GameFileImportPath);
+                Platform? determinedPlatform = Metadata.Platforms.GetPlatform((long)discoveredSignature.Flags.PlatformId);
+                Models.Game? determinedGame = Metadata.Games.GetGame(discoveredSignature.Flags.GameMetadataSource, discoveredSignature.Flags.GameId);
+                long RomId = StoreGame(GameLibrary.GetDefaultLibrary, Hash, discoveredSignature, determinedPlatform, FilePath, 0, true);
+                Roms.GameRomItem romItem = Roms.GetRom(RomId);
+
+                // build return value
+                GameFileInfo.Add("romid", RomId);
+                GameFileInfo.Add("platform", determinedPlatform);
+                GameFileInfo.Add("game", determinedGame);
+                GameFileInfo.Add("signature", discoveredSignature);
+                GameFileInfo.Add("rom", romItem);
+                GameFileInfo.Add("status", "imported");
+            }
+        }
+
+        /// <summary>
+        /// Store a game in the database and move the file to the library (if required)
+        /// </summary>
+        /// <param name="library">
+        /// The library to store the game in
+        /// </param>
+        /// <param name="hash">
+        /// The hash of the game file
+        /// </param>
+        /// <param name="signature">
+        /// The signature of the game file
+        /// </param>
+        /// <param name="filePath">
+        /// The path to the game file
+        /// </param>
+        /// <param name="romId">
+        /// The ID of the ROM in the database (if it already exists, 0 if it doesn't)
+        /// </param>
+        /// <param name="SourceIsExternal">
+        /// Whether the source of the file is external to the library
+        /// </param>
+        public static long StoreGame(GameLibrary.LibraryItem library, Common.hashObject hash, Signatures_Games signature, Platform platform, string filePath, long romId = 0, bool SourceIsExternal = false)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+
+            string sql = "";
+
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+
+            // add/get the metadata map
+            MetadataMap? map = MetadataManagement.NewMetadataMap((long)platform.Id, signature.Game.Name);
+
+            // add any metadata attributes that may be supplied as part of the signature
+            if (signature.Game.UserManual != null)
+            {
+                if (signature.Game.UserManual.Length > 0)
+                {
+                    MetadataManagement.SetMetadataSupportData((long)map.Id, MetadataManagement.MetadataMapSupportDataTypes.UserManualLink, signature.Game.UserManual);
+                }
+            }
+
+            // populate map with the sources from the signature if they don't already exist
+            foreach (MetadataSources source in Enum.GetValues(typeof(MetadataSources)))
+            {
+                bool sourceExists = false;
+
+                if (source != MetadataSources.None)
+                {
+                    // get the signature that matches this source
+                    Signatures_Games.SourceValues.SourceValueItem? signatureSource = signature.MetadataSources.Games.Find(x => x.Source == source);
+                    if (signatureSource == null)
+                    {
+                        Logging.Log(Logging.LogType.Information, "Import Game", "  No source found for " + source.ToString());
+                        continue;
+                    }
+
+                    // get the metadata map for this source
+                    MetadataMap.MetadataMapItem? mapSource = map.MetadataMapItems.Find(x => x.SourceType == source);
+                    if (mapSource == null)
+                    {
+                        // add the source to the map
+                        bool preferred = false;
+                        if (source == Config.MetadataConfiguration.DefaultMetadataSource)
+                        {
+                            preferred = true;
+                        }
+                        MetadataManagement.AddMetadataMapItem((long)map.Id, source, signatureSource.Id, preferred);
+                    }
+                    else
+                    {
+                        // update the source in the map - do not modify the preferred status
+                        MetadataManagement.UpdateMetadataMapItem((long)map.Id, source, signatureSource.Id, null);
+                    }
+                }
+            }
+
+            // reload the map
+            map = MetadataManagement.GetMetadataMap((long)map.Id);
+
+            // add or update the rom
+            dbDict = new Dictionary<string, object>();
+            if (romId == 0)
+            {
+                sql = "INSERT INTO Games_Roms (PlatformId, GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, RelativePath, MetadataSource, MetadataGameName, MetadataVersion, LibraryId, RomDataVersion, MetadataMapId) VALUES (@platformid, @gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @Attributes, @romtype, @romtypemedia, @medialabel, @path, @metadatasource, @metadatagamename, @metadataversion, @libraryid, @romdataversion, @metadatamapid); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+            }
+            else
+            {
+                sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid, Name=@name, Size=@size, DevelopmentStatus=@developmentstatus, Attributes=@Attributes, RomType=@romtype, RomTypeMedia=@romtypemedia, MediaLabel=@medialabel, MetadataSource=@metadatasource, MetadataGameName=@metadatagamename, MetadataVersion=@metadataversion, RomDataVersion=@romdataversion, MetadataMapId=@metadatamapid WHERE Id=@id;";
+                dbDict.Add("id", romId);
+            }
+            dbDict.Add("platformid", Common.ReturnValueIfNull(platform.Id, 0));
+            dbDict.Add("gameid", 0); // set to 0 - no longer required as game is mapped using the MetadataMapBridge table
+            dbDict.Add("name", Common.ReturnValueIfNull(signature.Rom.Name, 0));
+            dbDict.Add("size", Common.ReturnValueIfNull(signature.Rom.Size, 0));
+            dbDict.Add("md5", hash.md5hash);
+            dbDict.Add("sha1", hash.sha1hash);
+            dbDict.Add("crc", Common.ReturnValueIfNull(signature.Rom.Crc, ""));
+            dbDict.Add("developmentstatus", Common.ReturnValueIfNull(signature.Rom.DevelopmentStatus, ""));
+            dbDict.Add("metadatasource", signature.Rom.SignatureSource);
+            dbDict.Add("metadatagamename", signature.Game.Name);
+            dbDict.Add("metadataversion", 2);
+            dbDict.Add("libraryid", library.Id);
+            dbDict.Add("romdataversion", 2);
+            dbDict.Add("metadatamapid", map.Id);
+
+            if (signature.Rom.Attributes != null)
+            {
+                if (signature.Rom.Attributes.Count > 0)
+                {
+                    dbDict.Add("attributes", Newtonsoft.Json.JsonConvert.SerializeObject(signature.Rom.Attributes));
+                }
+                else
+                {
+                    dbDict.Add("attributes", "[ ]");
                 }
             }
             else
             {
-                    // file is a bios
-                    if (IsBios.WebEmulator != null)
+                dbDict.Add("attributes", "[ ]");
+            }
+            dbDict.Add("romtype", (int)signature.Rom.RomType);
+            dbDict.Add("romtypemedia", Common.ReturnValueIfNull(signature.Rom.RomTypeMedia, ""));
+            dbDict.Add("medialabel", Common.ReturnValueIfNull(signature.Rom.MediaLabel, ""));
+
+            string libraryRootPath = library.Path;
+            if (libraryRootPath.EndsWith(Path.DirectorySeparatorChar.ToString()) == false)
             {
-                        foreach (Classes.Bios.BiosItem biosItem in Classes.Bios.GetBios())
+                libraryRootPath += Path.DirectorySeparatorChar;
+            }
+            dbDict.Add("path", filePath.Replace(libraryRootPath, ""));
+
+            DataTable romInsert = db.ExecuteCMD(sql, dbDict);
+            if (romId == 0)
             {
-                            if (biosItem.Available == false && biosItem.hash == hash.md5hash)
-                            {
-                                string biosPath = biosItem.biosPath.Replace(biosItem.filename, "");
-                                if (!Directory.Exists(biosPath))
-                                {
-                                    Directory.CreateDirectory(biosPath);
+                romId = (long)romInsert.Rows[0][0];
             }
 
-                                File.Move(GameFileImportPath, biosItem.biosPath, true);
-
-                                break;
-                            }
-                        }
-                    }
-                }
-			}
+            // move to destination
+            if (library.IsDefaultLibrary == true)
+            {
+                MoveGameFile(romId, SourceIsExternal);
             }
 
-        public static IGDB.Models.Game SearchForGame(gaseous_server.Models.Signatures_Games Signature, long PlatformId, bool FullDownload)
+            return romId;
+        }
+
+        public static gaseous_server.Models.Game SearchForGame(gaseous_server.Models.Signatures_Games Signature, long PlatformId, bool FullDownload)
         {
             if (Signature.Flags != null)
             {
-                if (Signature.Flags.IGDBGameId != null && Signature.Flags.IGDBGameId != 0)
+                if (Signature.Flags.GameId != null && Signature.Flags.GameId != 0)
                 {
                     // game was determined elsewhere - probably a Hasheous server
                     try
                     {
-                        return Games.GetGame(Signature.Flags.IGDBGameId, false, false, FullDownload);
+                        return Games.GetGame(MetadataSources.IGDB, Signature.Flags.GameId);
                     }
                     catch (Exception ex)
                     {
@@ -168,7 +340,7 @@ namespace gaseous_server.Classes
             }
 
             // search discovered game - case insensitive exact match first
-            IGDB.Models.Game determinedGame = new IGDB.Models.Game();
+            gaseous_server.Models.Game determinedGame = new gaseous_server.Models.Game();
 
             string GameName = Signature.Game.Name;
 
@@ -183,11 +355,13 @@ namespace gaseous_server.Classes
                 foreach (Metadata.Games.SearchType searchType in Enum.GetValues(typeof(Metadata.Games.SearchType)))
                 {
                     Logging.Log(Logging.LogType.Information, "Import Game", "  Search type: " + searchType.ToString());
-                    IGDB.Models.Game[] games = Metadata.Games.SearchForGame(SearchCandidate, PlatformId, searchType);
+                    gaseous_server.Models.Game[] games = Metadata.Games.SearchForGame(SearchCandidate, PlatformId, searchType);
+                    if (games != null)
+                    {
                         if (games.Length == 1)
                         {
                             // exact match!
-                        determinedGame = Metadata.Games.GetGame((long)games[0].Id, false, false, false);
+                            determinedGame = Metadata.Games.GetGame(MetadataSources.IGDB, (long)games[0].Id);
                             Logging.Log(Logging.LogType.Information, "Import Game", "  IGDB game: " + determinedGame.Name);
                             GameFound = true;
                             break;
@@ -197,10 +371,12 @@ namespace gaseous_server.Classes
                             Logging.Log(Logging.LogType.Information, "Import Game", "  " + games.Length + " search results found");
 
                             // quite likely we've found sequels and alternate types
-                        foreach (Game game in games) {
-                            if (game.Name == SearchCandidate) {
+                            foreach (gaseous_server.Models.Game game in games)
+                            {
+                                if (game.Name == SearchCandidate)
+                                {
                                     // found game title matches the search candidate
-                                determinedGame = Metadata.Games.GetGame((long)games[0].Id, false, false, false);
+                                    determinedGame = Metadata.Games.GetGame(MetadataSources.IGDB, (long)games[0].Id);
                                     Logging.Log(Logging.LogType.Information, "Import Game", "Found exact match!");
                                     GameFound = true;
                                     break;
@@ -212,11 +388,16 @@ namespace gaseous_server.Classes
                             Logging.Log(Logging.LogType.Information, "Import Game", "  No search results found");
                         }
                     }
+                    else
+                    {
+                        Logging.Log(Logging.LogType.Information, "Import Game", "  No search results found");
+                    }
+                }
                 if (GameFound == true) { break; }
             }
             if (determinedGame == null)
             {
-                determinedGame = new IGDB.Models.Game();
+                determinedGame = new gaseous_server.Models.Game();
             }
 
             string destSlug = "";
@@ -228,9 +409,9 @@ namespace gaseous_server.Classes
             return determinedGame;
         }
 
-        public static List<IGDB.Models.Game> SearchForGame_GetAll(string GameName, long PlatformId)
+        public static List<gaseous_server.Models.Game> SearchForGame_GetAll(string GameName, long PlatformId)
         {
-            List<IGDB.Models.Game> searchResults = new List<IGDB.Models.Game>();
+            List<gaseous_server.Models.Game> searchResults = new List<gaseous_server.Models.Game>();
 
             List<string> SearchCandidates = GetSearchCandidates(GameName);
 
@@ -240,11 +421,11 @@ namespace gaseous_server.Classes
                 {
                     if ((PlatformId == 0 && searchType == SearchType.searchNoPlatform) || (PlatformId != 0 && searchType != SearchType.searchNoPlatform))
                     {
-                        IGDB.Models.Game[] games = Metadata.Games.SearchForGame(SearchCandidate, PlatformId, searchType);
-                        foreach (IGDB.Models.Game foundGame in games)
+                        gaseous_server.Models.Game[] games = Metadata.Games.SearchForGame(SearchCandidate, PlatformId, searchType);
+                        foreach (gaseous_server.Models.Game foundGame in games)
                         {
                             bool gameInResults = false;
-                            foreach (IGDB.Models.Game searchResult in searchResults)
+                            foreach (gaseous_server.Models.Game searchResult in searchResults)
                             {
                                 if (searchResult.Id == foundGame.Id)
                                 {
@@ -273,7 +454,8 @@ namespace gaseous_server.Classes
 
             // assumption: no games have () in their titles so we'll remove them
             int idx = GameName.IndexOf('(');
-            if (idx >= 0) {
+            if (idx >= 0)
+            {
                 GameName = GameName.Substring(0, idx);
             }
 
@@ -294,81 +476,14 @@ namespace gaseous_server.Classes
             return SearchCandidates;
         }
 
-        public static long StoreROM(GameLibrary.LibraryItem library, Common.hashObject hash, IGDB.Models.Game determinedGame, IGDB.Models.Platform determinedPlatform, gaseous_server.Models.Signatures_Games discoveredSignature, string GameFileImportPath, long UpdateId = 0)
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-            string sql = "";
-
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-
-            if (UpdateId == 0)
-            {
-                sql = "INSERT INTO Games_Roms (PlatformId, GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, Path, MetadataSource, MetadataGameName, MetadataVersion, LibraryId) VALUES (@platformid, @gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @Attributes, @romtype, @romtypemedia, @medialabel, @path, @metadatasource, @metadatagamename, @metadataversion, @libraryid); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-            } else
-            {
-                sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid, Name=@name, Size=@size, DevelopmentStatus=@developmentstatus, Attributes=@Attributes, RomType=@romtype, RomTypeMedia=@romtypemedia, MediaLabel=@medialabel, MetadataSource=@metadatasource, MetadataGameName=@metadatagamename, MetadataVersion=@metadataversion WHERE Id=@id;";
-                dbDict.Add("id", UpdateId);
-            }
-            dbDict.Add("platformid", Common.ReturnValueIfNull(determinedPlatform.Id, 0));
-            dbDict.Add("gameid", Common.ReturnValueIfNull(determinedGame.Id, 0));
-            dbDict.Add("name", Common.ReturnValueIfNull(discoveredSignature.Rom.Name, 0));
-            dbDict.Add("size", Common.ReturnValueIfNull(discoveredSignature.Rom.Size, 0));
-            dbDict.Add("md5", hash.md5hash);
-            dbDict.Add("sha1", hash.sha1hash);
-            dbDict.Add("crc", Common.ReturnValueIfNull(discoveredSignature.Rom.Crc, ""));
-            dbDict.Add("developmentstatus", Common.ReturnValueIfNull(discoveredSignature.Rom.DevelopmentStatus, ""));
-            dbDict.Add("metadatasource", discoveredSignature.Rom.SignatureSource);
-            dbDict.Add("metadatagamename", discoveredSignature.Game.Name);
-            dbDict.Add("metadataversion", 2);
-            dbDict.Add("libraryid", library.Id);
-
-            if (discoveredSignature.Rom.Attributes != null)
-            {
-                if (discoveredSignature.Rom.Attributes.Count > 0)
-                {
-                    dbDict.Add("attributes", Newtonsoft.Json.JsonConvert.SerializeObject(discoveredSignature.Rom.Attributes));
-                }
-                else
-                {
-                    dbDict.Add("attributes", "[ ]");
-                }
-            }
-            else
-            {
-                dbDict.Add("attributes", "[ ]");
-            }
-            dbDict.Add("romtype", (int)discoveredSignature.Rom.RomType);
-            dbDict.Add("romtypemedia", Common.ReturnValueIfNull(discoveredSignature.Rom.RomTypeMedia, ""));
-            dbDict.Add("medialabel", Common.ReturnValueIfNull(discoveredSignature.Rom.MediaLabel, ""));
-            dbDict.Add("path", GameFileImportPath);
-
-            DataTable romInsert = db.ExecuteCMD(sql, dbDict);
-            long romId = 0;
-            if (UpdateId == 0)
-            {
-                romId = (long)romInsert.Rows[0][0];
-            } else
-            {
-                romId = UpdateId;
-            }
-
-            // move to destination
-            if (library.IsDefaultLibrary == true)
-            {
-                MoveGameFile(romId);
-            }
-
-            return romId;
-        }
-
         public static string ComputeROMPath(long RomId)
         {
             Classes.Roms.GameRomItem rom = Classes.Roms.GetRom(RomId);
 
             // get metadata
-			IGDB.Models.Platform platform = gaseous_server.Classes.Metadata.Platforms.GetPlatform(rom.PlatformId);
-			IGDB.Models.Game game = gaseous_server.Classes.Metadata.Games.GetGame(rom.GameId, false, false, false);
+            MetadataMap.MetadataMapItem metadataMap = Classes.MetadataManagement.GetMetadataMap(rom.MetadataMapId).PreferredMetadataMapItem;
+            Platform? platform = gaseous_server.Classes.Metadata.Platforms.GetPlatform(rom.PlatformId);
+            gaseous_server.Models.Game? game = Classes.Metadata.Games.GetGame(metadataMap.SourceType, metadataMap.SourceId);
 
             // build path
             string platformSlug = "Unknown Platform";
@@ -381,7 +496,7 @@ namespace gaseous_server.Classes
             {
                 gameSlug = game.Slug;
             }
-			string DestinationPath = Path.Combine(GameLibrary.GetDefaultLibrary.Path, gameSlug, platformSlug);
+            string DestinationPath = Path.Combine(GameLibrary.GetDefaultLibrary.Path, platformSlug);
             if (!Directory.Exists(DestinationPath))
             {
                 Directory.CreateDirectory(DestinationPath);
@@ -392,10 +507,14 @@ namespace gaseous_server.Classes
             return DestinationPathName;
         }
 
-		public static bool MoveGameFile(long RomId)
+        public static bool MoveGameFile(long RomId, bool SourceIsExternal)
         {
             Classes.Roms.GameRomItem rom = Classes.Roms.GetRom(RomId);
             string romPath = rom.Path;
+            if (SourceIsExternal == true)
+            {
+                romPath = rom.RelativePath;
+            }
 
             if (File.Exists(romPath))
             {
@@ -420,10 +539,16 @@ namespace gaseous_server.Classes
 
                         // update the db
                         Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-						string sql = "UPDATE Games_Roms SET Path=@path WHERE Id=@id";
+                        string sql = "UPDATE Games_Roms SET RelativePath=@path WHERE Id=@id";
                         Dictionary<string, object> dbDict = new Dictionary<string, object>();
                         dbDict.Add("id", RomId);
-						dbDict.Add("path", DestinationPath);
+
+                        string libraryRootPath = rom.Library.Path;
+                        if (libraryRootPath.EndsWith(Path.DirectorySeparatorChar.ToString()) == false)
+                        {
+                            libraryRootPath += Path.DirectorySeparatorChar;
+                        }
+                        dbDict.Add("path", DestinationPath.Replace(libraryRootPath, ""));
                         db.ExecuteCMD(sql, dbDict);
 
                         return true;
@@ -445,7 +570,7 @@ namespace gaseous_server.Classes
 
             // move rom files to their new location
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT * FROM Games_Roms WHERE LibraryId = @libraryid";
+            string sql = "SELECT * FROM view_Games_Roms WHERE LibraryId = @libraryid";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             dbDict.Add("libraryid", library.Id);
             DataTable romDT = db.ExecuteCMD(sql, dbDict);
@@ -457,7 +582,7 @@ namespace gaseous_server.Classes
                     SetStatus(i, romDT.Rows.Count, "Processing file " + romDT.Rows[i]["name"]);
                     Logging.Log(Logging.LogType.Information, "Organise Library", "(" + i + "/" + romDT.Rows.Count + ") Processing ROM " + romDT.Rows[i]["name"]);
                     long RomId = (long)romDT.Rows[i]["id"];
-					MoveGameFile(RomId);
+                    MoveGameFile(RomId, false);
                 }
             }
             ClearStatus();
@@ -485,22 +610,40 @@ namespace gaseous_server.Classes
             }
         }
 
-        public void LibraryScan(GameLibrary.LibraryItem? singleLibrary = null)
+        public static List<GameLibrary.LibraryItem> LibrariesToScan = new List<GameLibrary.LibraryItem>();
+        public void LibraryScan()
         {
-            int maxWorkers = Config.MetadataConfiguration.MaxLibraryScanWorkers;
+            int maxWorkers = 4;
 
-            List<GameLibrary.LibraryItem> libraries = new List<GameLibrary.LibraryItem>();
-            if (singleLibrary == null)
+            if (LibrariesToScan.Count == 0)
             {
-                libraries.AddRange(GameLibrary.GetLibraries);
-            }
-            else
-            {
-                libraries.Add(singleLibrary);
+                LibrariesToScan.AddRange(GameLibrary.GetLibraries);
             }
 
             // setup background tasks for each library
-            foreach (GameLibrary.LibraryItem library in libraries)
+            do
+            {
+                Logging.Log(Logging.LogType.Information, "Library Scan", "Library scan queue size: " + LibrariesToScan.Count);
+
+                GameLibrary.LibraryItem library = LibrariesToScan[0];
+                LibrariesToScan.RemoveAt(0);
+
+                // check if library is already being scanned
+                bool libraryAlreadyScanning = false;
+                List<ProcessQueue.QueueItem> ProcessQueueItems = new List<ProcessQueue.QueueItem>();
+                ProcessQueueItems.AddRange(ProcessQueue.QueueItems);
+                foreach (ProcessQueue.QueueItem item in ProcessQueueItems)
+                {
+                    if (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker)
+                    {
+                        if (((GameLibrary.LibraryItem)item.Options).Id == library.Id)
+                        {
+                            libraryAlreadyScanning = true;
+                        }
+                    }
+                }
+
+                if (libraryAlreadyScanning == false)
                 {
                     Logging.Log(Logging.LogType.Information, "Library Scan", "Starting worker process for library " + library.Name);
                     ProcessQueue.QueueItem queue = new ProcessQueue.QueueItem(
@@ -508,12 +651,13 @@ namespace gaseous_server.Classes
                         1,
                         new List<ProcessQueue.QueueItemType>
                         {
-                        ProcessQueue.QueueItemType.OrganiseLibrary,
-                        ProcessQueue.QueueItemType.Rematcher
+                        ProcessQueue.QueueItemType.OrganiseLibrary
                         },
                         false,
-                    true);
-                queue.Options = library;
+                        true)
+                    {
+                        Options = library
+                    };
                     queue.ForceExecute();
 
                     ProcessQueue.QueueItems.Add(queue);
@@ -524,9 +668,9 @@ namespace gaseous_server.Classes
                     {
                         allowContinue = true;
                         int currentWorkerCount = 0;
-                    List<ProcessQueue.QueueItem> queueItems = new List<ProcessQueue.QueueItem>();
-                    queueItems.AddRange(ProcessQueue.QueueItems);
-                    foreach (ProcessQueue.QueueItem item in queueItems)
+                        List<ProcessQueue.QueueItem> LibraryScan_QueueItems = new List<ProcessQueue.QueueItem>();
+                        LibraryScan_QueueItems.AddRange(ProcessQueue.QueueItems);
+                        foreach (ProcessQueue.QueueItem item in LibraryScan_QueueItems)
                         {
                             if (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker)
                             {
@@ -540,6 +684,7 @@ namespace gaseous_server.Classes
                         }
                     } while (allowContinue == false);
                 }
+            } while (LibrariesToScan.Count > 0);
 
             bool WorkersStillWorking;
             do
@@ -559,6 +704,12 @@ namespace gaseous_server.Classes
             } while (WorkersStillWorking == true);
 
             Logging.Log(Logging.LogType.Information, "Library Scan", "Library scan complete. All workers stopped");
+
+            if (LibrariesToScan.Count > 0)
+            {
+                Logging.Log(Logging.LogType.Information, "Library Scan", "There are still libraries to scan. Restarting scan process");
+                LibraryScan();
+            }
         }
 
         public void LibrarySpecificScan(GameLibrary.LibraryItem library)
@@ -574,7 +725,7 @@ namespace gaseous_server.Classes
             dupDict.Add("libraryid", library.Id);
             db.ExecuteCMD(duplicateSql, dupDict);
 
-            string sql = "SELECT * FROM Games_Roms WHERE LibraryId=@libraryid ORDER BY `name`";
+            string sql = "SELECT * FROM view_Games_Roms WHERE LibraryId=@libraryid ORDER BY `name`";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             dbDict.Add("libraryid", library.Id);
             DataTable dtRoms = db.ExecuteCMD(sql, dbDict);
@@ -599,7 +750,7 @@ namespace gaseous_server.Classes
                 }
             }
 
-            sql = "SELECT * FROM Games_Roms WHERE LibraryId=@libraryid ORDER BY `name`";
+            sql = "SELECT * FROM view_Games_Roms WHERE LibraryId=@libraryid ORDER BY `name`";
             dtRoms = db.ExecuteCMD(sql, dbDict);
 
             // search for files in the library that aren't in the database
@@ -643,9 +794,9 @@ namespace gaseous_server.Classes
                         {
                             // get discovered platform
                             long PlatformId;
-                            IGDB.Models.Platform determinedPlatform;
+                            Platform determinedPlatform;
 
-                            if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0 )
+                            if (sig.Flags.PlatformId == null || sig.Flags.PlatformId == 0)
                             {
                                 // no platform discovered in the signature
                                 PlatformId = library.DefaultPlatformId;
@@ -653,13 +804,13 @@ namespace gaseous_server.Classes
                             else
                             {
                                 // use the platform discovered in the signature
-                                PlatformId = sig.Flags.IGDBPlatformId;
+                                PlatformId = (long)sig.Flags.PlatformId;
                             }
                             determinedPlatform = Platforms.GetPlatform(PlatformId);
 
-                            IGDB.Models.Game determinedGame = SearchForGame(sig, PlatformId, true);
+                            gaseous_server.Models.Game determinedGame = SearchForGame(sig, PlatformId, true);
 
-                            StoreROM(library, hash, determinedGame, determinedPlatform, sig, LibraryFile);
+                            StoreGame(library, hash, sig, determinedPlatform, LibraryFile, 0, false);
                         }
                         catch (Exception ex)
                         {
@@ -671,7 +822,7 @@ namespace gaseous_server.Classes
             }
             ClearStatus();
 
-            sql = "SELECT * FROM Games_Roms WHERE LibraryId=@libraryid ORDER BY `name`";
+            sql = "SELECT * FROM view_Games_Roms WHERE LibraryId=@libraryid ORDER BY `name`";
             dtRoms = db.ExecuteCMD(sql, dbDict);
 
             // check all roms to see if their local file still exists
@@ -695,7 +846,7 @@ namespace gaseous_server.Classes
                             if (romPath != ComputeROMPath(romId))
                             {
                                 Logging.Log(Logging.LogType.Information, "Library Scan", "ROM at path " + romPath + " found, but needs to be moved");
-                                MoveGameFile(romId);
+                                MoveGameFile(romId, false);
                             }
                             else
                             {
@@ -721,86 +872,6 @@ namespace gaseous_server.Classes
 
             Logging.Log(Logging.LogType.Information, "Library Scan", "Library scan completed");
         }
-
-        public void Rematcher(bool ForceExecute = false)
-        {
-            // rescan all titles with an unknown platform or title and see if we can get a match
-            Logging.Log(Logging.LogType.Information, "Rematch Scan", "Rematch scan starting");
-
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-            foreach (GameLibrary.LibraryItem library in GameLibrary.GetLibraries)
-            {
-                Logging.Log(Logging.LogType.Information, "Rematch Scan", "Rematch on library " + library.Name);
-
-                string sql = "";
-                if (ForceExecute == false)
-                {
-                    sql = "SELECT * FROM Games_Roms WHERE (PlatformId = 0 AND GameId <> 0) OR (((PlatformId = 0 OR GameId = 0) AND MetadataSource = 0) OR (PlatformId = 0 AND GameId = 0)) AND (LastMatchAttemptDate IS NULL OR LastMatchAttemptDate < @lastmatchattemptdate) AND LibraryId = @libraryid LIMIT 100;";
-                }
-                else
-                {
-                    sql = "SELECT * FROM Games_Roms WHERE (PlatformId = 0 AND GameId <> 0) OR (((PlatformId = 0 OR GameId = 0) AND MetadataSource = 0) OR (PlatformId = 0 AND GameId = 0)) AND LibraryId = @libraryid;";
-                }
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("lastmatchattemptdate", DateTime.UtcNow.AddDays(-7));
-                dbDict.Add("libraryid", library.Id);
-                DataTable data = db.ExecuteCMD(sql, dbDict);
-                int StatusCount = -0;
-                foreach (DataRow row in data.Rows)
-                {
-                    SetStatus(StatusCount, data.Rows.Count, "Running rematcher");
-
-                    // get rom info
-                    long romId = (long)row["Id"];
-                    string romPath = (string)row["Path"];
-                    Common.hashObject hash = new Common.hashObject
-                    {
-                        md5hash = (string)row["MD5"],
-                        sha1hash = (string)row["SHA1"]
-                    };
-                    FileInfo fi = new FileInfo(romPath);
-
-                    Logging.Log(Logging.LogType.Information, "Rematch Scan", "Running rematch against " + romPath);
-
-                    // determine rom signature
-                    FileSignature fileSignature = new FileSignature();
-                    gaseous_server.Models.Signatures_Games sig = fileSignature.GetFileSignature(library, hash, fi, romPath);
-
-                    // get discovered platform
-                    long PlatformId;
-                    IGDB.Models.Platform determinedPlatform;
-                    
-                    if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0 )
-                    {
-                        // no platform discovered in the signature
-                        PlatformId = library.DefaultPlatformId;
-                    }
-                    else
-                    {
-                        // use the platform discovered in the signature
-                        PlatformId = sig.Flags.IGDBPlatformId;
-                    }
-                    determinedPlatform = Platforms.GetPlatform(PlatformId);
-
-                    IGDB.Models.Game determinedGame = SearchForGame(sig, PlatformId, true);
-
-                    StoreROM(library, hash, determinedGame, determinedPlatform, sig, romPath, romId);
-
-                    string attemptSql = "UPDATE Games_Roms SET LastMatchAttemptDate=@lastmatchattemptdate WHERE Id=@id;";
-                    Dictionary<string, object> dbLastAttemptDict = new Dictionary<string, object>();
-                    dbLastAttemptDict.Add("id", romId);
-                    dbLastAttemptDict.Add("lastmatchattemptdate", DateTime.UtcNow);
-                    db.ExecuteCMD(attemptSql, dbLastAttemptDict);
-
-                    StatusCount += 1;
-                }
-                ClearStatus();
-
-                Logging.Log(Logging.LogType.Information, "Rematch Scan", "Rematch scan completed");
-                ClearStatus();
-            }
-        }
     }
 }
 

gaseous-server/Classes/Logging.cs

@@ -3,6 +3,7 @@ using System.Data;
 using System.Diagnostics;
 using System.Reflection;
 using System.Reflection.Metadata.Ecma335;
+using Microsoft.VisualStudio.Web.CodeGenerators.Mvc.Templates.BlazorIdentity.Pages;
 namespace gaseous_server.Classes
 {
     public class Logging
@@ -21,8 +22,13 @@ namespace gaseous_server.Classes
                 ExceptionValue = Common.ReturnValueIfNull(ExceptionValue, "").ToString()
             };
 
+            _ = Task.Run(() => WriteLogAsync(logItem, LogToDiskOnly));
+        }
+
+        static async Task WriteLogAsync(LogItem logItem, bool LogToDiskOnly)
+        {
             bool AllowWrite = false;
-            if (EventType == LogType.Debug)
+            if (logItem.EventType == LogType.Debug)
             {
                 if (Config.LoggingConfiguration.DebugLogging == true)
                 {
@@ -42,26 +48,32 @@ namespace gaseous_server.Classes
                 {
                     TraceOutput += Environment.NewLine + logItem.ExceptionValue.ToString();
                 }
-                switch(logItem.EventType) {
+                string consoleColour = "";
+                switch (logItem.EventType)
+                {
                     case LogType.Information:
-                        Console.ForegroundColor = ConsoleColor.Blue;
+                        // Console.ForegroundColor = ConsoleColor.Blue;
+                        consoleColour = "\u001b[1;34m]";
                         break;
 
                     case LogType.Warning:
-                        Console.ForegroundColor = ConsoleColor.Yellow;
+                        // Console.ForegroundColor = ConsoleColor.Yellow;
+                        consoleColour = "\u001b[1;33m]";
                         break;
 
                     case LogType.Critical:
-                        Console.ForegroundColor = ConsoleColor.Red;
+                        // Console.ForegroundColor = ConsoleColor.Red;
+                        consoleColour = "\u001b[1;31m]";
                         break;
 
                     case LogType.Debug:
-                        Console.ForegroundColor = ConsoleColor.Magenta;
+                        // Console.ForegroundColor = ConsoleColor.Magenta;
+                        consoleColour = "\u001b[1;36m]";
                         break;
 
                 }
-                Console.WriteLine(TraceOutput);
-                Console.ResetColor();
+                Console.WriteLine(consoleColour + TraceOutput);
+                // Console.ResetColor();
 
                 if (WriteToDiskOnly == true)
                 {

gaseous-server/Classes/Maintenance.cs

@@ -16,6 +16,7 @@ namespace gaseous_server.Classes
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
 
             // remove any entries from the library that have an invalid id
+            Logging.Log(Logging.LogType.Information, "Maintenance", "Removing any entries from the library that have an invalid id");
             string LibraryWhereClause = "";
             foreach (GameLibrary.LibraryItem library in GameLibrary.GetLibraries)
             {
@@ -33,9 +34,29 @@ namespace gaseous_server.Classes
             }
 
             // delete old logs
-            sql = "DELETE FROM ServerLogs WHERE EventTime < @EventRetentionDate;";
+            Logging.Log(Logging.LogType.Information, "Maintenance", "Removing logs older than " + Config.LoggingConfiguration.LogRetention + " days");
+            long deletedCount = 1;
+            long deletedEventCount = 0;
+            long maxLoops = 10000;
+            sql = "DELETE FROM ServerLogs WHERE EventTime < @EventRetentionDate LIMIT 1000; SELECT ROW_COUNT() AS Count;";
             dbDict.Add("EventRetentionDate", DateTime.UtcNow.AddDays(Config.LoggingConfiguration.LogRetention * -1));
-            db.ExecuteCMD(sql, dbDict);
+            while (deletedCount > 0)
+            {
+                DataTable deletedCountTable = db.ExecuteCMD(sql, dbDict);
+                deletedCount = (long)deletedCountTable.Rows[0][0];
+                deletedEventCount += deletedCount;
+
+                Logging.Log(Logging.LogType.Information, "Maintenance", "Deleted " + deletedCount + " log entries");
+
+                // check if we've hit the limit
+                maxLoops -= 1;
+                if (maxLoops <= 0)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Maintenance", "Hit the maximum number of loops for deleting logs. Stopping.");
+                    break;
+                }
+            }
+            Logging.Log(Logging.LogType.Information, "Maintenance", "Deleted " + deletedEventCount + " log entries");
 
             // delete files and directories older than 7 days in PathsToClean
             List<string> PathsToClean = new List<string>();
@@ -87,7 +108,7 @@ namespace gaseous_server.Classes
                 SetStatus(StatusCounter, tables.Rows.Count, "Optimising table " + row[0].ToString());
 
                 sql = "OPTIMIZE TABLE " + row[0].ToString();
-                DataTable response = db.ExecuteCMD(sql);
+                DataTable response = db.ExecuteCMD(sql, new Dictionary<string, object>(), 240);
                 foreach (DataRow responseRow in response.Rows)
                 {
                     string retVal = "";

gaseous-server/Classes/Metadata/AgeGroups.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Reflection;
 using System.Text.Json.Serialization;
-using IGDB;
-using IGDB.Models;
+using gaseous_server.Models;
+using HasheousClient.Models.Metadata.IGDB;
 using Microsoft.CodeAnalysis.Classification;
 
 namespace gaseous_server.Classes.Metadata
@@ -14,7 +14,7 @@ namespace gaseous_server.Classes.Metadata
 
         }
 
-        public static AgeGroup? GetAgeGroup(Game? game)
+        public static AgeGroup? GetAgeGroup(Models.Game? game)
         {
             if (game == null)
             {
@@ -23,7 +23,7 @@ namespace gaseous_server.Classes.Metadata
             else
             {
                 Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-                cacheStatus = Storage.GetCacheStatus("AgeGroup", (long)game.Id);
+                cacheStatus = Storage.GetCacheStatus(HasheousClient.Models.MetadataSources.IGDB, "AgeGroup", (long)game.Id);
 
                 AgeGroup? RetVal = new AgeGroup();
 
@@ -31,16 +31,16 @@ namespace gaseous_server.Classes.Metadata
                 {
                     case Storage.CacheStatus.NotPresent:
                         RetVal = _GetAgeGroup(game);
-                        Storage.NewCacheValue(RetVal, false);
+                        Storage.NewCacheValue(HasheousClient.Models.MetadataSources.IGDB, RetVal, false);
                         break;
 
                     case Storage.CacheStatus.Expired:
                         RetVal = _GetAgeGroup(game);
-                        Storage.NewCacheValue(RetVal, true);
+                        Storage.NewCacheValue(HasheousClient.Models.MetadataSources.IGDB, RetVal, true);
                         break;
 
                     case Storage.CacheStatus.Current:
-                        RetVal = Storage.GetCacheValue<AgeGroup>(RetVal, "Id", game.Id);
+                        RetVal = Storage.GetCacheValue<AgeGroup>(HasheousClient.Models.MetadataSources.IGDB, RetVal, "Id", game.Id);
                         break;
 
                     default:
@@ -51,20 +51,20 @@ namespace gaseous_server.Classes.Metadata
             }
         }
 
-        public static AgeGroup? _GetAgeGroup(Game game)
+        public static AgeGroup? _GetAgeGroup(Models.Game game)
         {
             // compile the maximum age group for the given game
             if (game != null)
             {
                 if (game.AgeRatings != null)
                 {
-                    if (game.AgeRatings.Ids != null)
+                    if (game.AgeRatings != null)
                     {
                         // collect ratings values from metadata
                         List<AgeRating> ageRatings = new List<AgeRating>();
-                        foreach (long ratingId in game.AgeRatings.Ids)
+                        foreach (long ratingId in game.AgeRatings)
                         {
-                            AgeRating? rating = AgeRatings.GetAgeRatings(ratingId);
+                            AgeRating? rating = AgeRatings.GetAgeRating(game.MetadataSource, ratingId);
                             if (rating != null)
                             {
                                 ageRatings.Add(rating);
@@ -216,7 +216,8 @@ namespace gaseous_server.Classes.Metadata
             }
         }
 
-        readonly static AgeGroupItem Adult_Item = new AgeGroupItem{
+        readonly static AgeGroupItem Adult_Item = new AgeGroupItem
+        {
             ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_R18, AgeRatingTitle.ACB_RC },
             CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_Z },
             CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_Eighteen },
@@ -226,7 +227,8 @@ namespace gaseous_server.Classes.Metadata
             USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_18 }
         };
 
-        readonly static AgeGroupItem Mature_Item = new AgeGroupItem{
+        readonly static AgeGroupItem Mature_Item = new AgeGroupItem
+        {
             ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_M, AgeRatingTitle.ACB_MA15 },
             CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_C, AgeRatingTitle.CERO_D },
             CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_Sixteen },
@@ -236,7 +238,8 @@ namespace gaseous_server.Classes.Metadata
             USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_16 }
         };
 
-        readonly static AgeGroupItem Teen_Item = new AgeGroupItem{
+        readonly static AgeGroupItem Teen_Item = new AgeGroupItem
+        {
             ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_PG },
             CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_B },
             CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_Twelve, AgeRatingTitle.CLASS_IND_Fourteen },
@@ -246,11 +249,12 @@ namespace gaseous_server.Classes.Metadata
             USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_12 }
         };
 
-        readonly static AgeGroupItem Child_Item = new AgeGroupItem{
+        readonly static AgeGroupItem Child_Item = new AgeGroupItem
+        {
             ACB = new List<AgeRatingTitle> { AgeRatingTitle.ACB_G },
             CERO = new List<AgeRatingTitle> { AgeRatingTitle.CERO_A },
             CLASS_IND = new List<AgeRatingTitle> { AgeRatingTitle.CLASS_IND_L, AgeRatingTitle.CLASS_IND_Ten },
-            ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.E, AgeRatingTitle.E10 },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.EC, AgeRatingTitle.E, AgeRatingTitle.E10 },
             GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_All },
             PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Three, AgeRatingTitle.Seven },
             USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_0, AgeRatingTitle.USK_6 }
@@ -258,13 +262,13 @@ namespace gaseous_server.Classes.Metadata
 
         public class AgeGroupItem
         {
-            public List<IGDB.Models.AgeRatingTitle> ACB { get; set; }
-            public List<IGDB.Models.AgeRatingTitle> CERO { get; set; }
-            public List<IGDB.Models.AgeRatingTitle> CLASS_IND { get; set; }
-            public List<IGDB.Models.AgeRatingTitle> ESRB { get; set; }
-            public List<IGDB.Models.AgeRatingTitle> GRAC { get; set; }
-            public List<IGDB.Models.AgeRatingTitle> PEGI { get; set; }
-            public List<IGDB.Models.AgeRatingTitle> USK { get; set; }
+            public List<AgeRatingTitle> ACB { get; set; }
+            public List<AgeRatingTitle> CERO { get; set; }
+            public List<AgeRatingTitle> CLASS_IND { get; set; }
+            public List<AgeRatingTitle> ESRB { get; set; }
+            public List<AgeRatingTitle> GRAC { get; set; }
+            public List<AgeRatingTitle> PEGI { get; set; }
+            public List<AgeRatingTitle> USK { get; set; }
 
             [JsonIgnore]
             [Newtonsoft.Json.JsonIgnore]

gaseous-server/Classes/Metadata/AgeRating.cs

@@ -1,21 +1,21 @@
 using System;
+using System.Buffers;
 using System.Reflection;
 using System.Text.Json.Serialization;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 using Microsoft.CodeAnalysis.Classification;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class AgeRatings
     {
-        const string fieldList = "fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;";
+        public const string fieldList = "fields category,checksum,content_descriptions,rating,rating_cover_url,synopsis;";
 
         public AgeRatings()
         {
         }
 
-        public static AgeRating? GetAgeRatings(long? Id)
+        public static AgeRating? GetAgeRating(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -23,106 +23,16 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<AgeRating> RetVal = _GetAgeRatings(SearchUsing.id, Id);
-                return RetVal.Result;
+                AgeRating? RetVal = Metadata.GetMetadata<AgeRating>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
 
-        public static AgeRating GetAgeRatings(string Slug)
-        {
-            Task<AgeRating> RetVal = _GetAgeRatings(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<AgeRating> _GetAgeRatings(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("AgeRating", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("AgeRating", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            AgeRating returnValue = new AgeRating();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    UpdateSubClasses(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<AgeRating>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<AgeRating>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private static void UpdateSubClasses(AgeRating ageRating)
-        {
-            if (ageRating.ContentDescriptions != null)
-            {
-                foreach (long AgeRatingContentDescriptionId in ageRating.ContentDescriptions.Ids)
-                {
-                    AgeRatingContentDescription ageRatingContentDescription = AgeRatingContentDescriptions.GetAgeRatingContentDescriptions(AgeRatingContentDescriptionId);
-                }
-            }
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<AgeRating> GetObjectFromServer(string WhereClause)
-        {
-            // get AgeRatings metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<AgeRating>(IGDBClient.Endpoints.AgeRating, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
-
-        public static GameAgeRating GetConsolidatedAgeRating(long RatingId)
+        public static GameAgeRating GetConsolidatedAgeRating(HasheousClient.Models.MetadataSources SourceType, long RatingId)
         {
             GameAgeRating gameAgeRating = new GameAgeRating();
 
-            AgeRating ageRating = GetAgeRatings(RatingId);
+            AgeRating ageRating = GetAgeRating(SourceType, RatingId);
             gameAgeRating.Id = (long)ageRating.Id;
             gameAgeRating.RatingBoard = (AgeRatingCategory)ageRating.Category;
             gameAgeRating.RatingTitle = (AgeRatingTitle)ageRating.Rating;
@@ -130,9 +40,9 @@ namespace gaseous_server.Classes.Metadata
             List<string> descriptions = new List<string>();
             if (ageRating.ContentDescriptions != null)
             {
-                foreach (long ContentId in ageRating.ContentDescriptions.Ids)
+                foreach (long ContentId in ageRating.ContentDescriptions)
                 {
-                    AgeRatingContentDescription ageRatingContentDescription = AgeRatingContentDescriptions.GetAgeRatingContentDescriptions(ContentId);
+                    AgeRatingContentDescription ageRatingContentDescription = AgeRatingContentDescriptions.GetAgeRatingContentDescriptions(SourceType, ContentId);
                     descriptions.Add(ageRatingContentDescription.Description);
                 }
             }

gaseous-server/Classes/Metadata/AgeRatingContentDescriptions.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class AgeRatingContentDescriptions
     {
-        const string fieldList = "fields category,checksum,description;";
+        public const string fieldList = "fields category,checksum,description;";
 
         public AgeRatingContentDescriptions()
         {
         }
 
-        public static AgeRatingContentDescription? GetAgeRatingContentDescriptions(long? Id)
+        public static AgeRatingContentDescription? GetAgeRatingContentDescriptions(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<AgeRatingContentDescription> RetVal = _GetAgeRatingContentDescriptions(SearchUsing.id, Id);
-                return RetVal.Result;
+                AgeRatingContentDescription? RetVal = Metadata.GetMetadata<AgeRatingContentDescription>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static AgeRatingContentDescription GetAgeRatingContentDescriptions(string Slug)
-        {
-            Task<AgeRatingContentDescription> RetVal = _GetAgeRatingContentDescriptions(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<AgeRatingContentDescription> _GetAgeRatingContentDescriptions(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("AgeRatingContentDescription", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("AgeRatingContentDescription", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            AgeRatingContentDescription returnValue = new AgeRatingContentDescription();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<AgeRatingContentDescription>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<AgeRatingContentDescription>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<AgeRatingContentDescription> GetObjectFromServer(string WhereClause)
-        {
-            // get AgeRatingContentDescriptionContentDescriptions metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<AgeRatingContentDescription>(IGDBClient.Endpoints.AgeRatingContentDescriptions, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/AlternativeNames.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class AlternativeNames
     {
-        const string fieldList = "fields checksum,comment,game,name;";
+        public const string fieldList = "fields checksum,comment,game,name;";
 
         public AlternativeNames()
         {
         }
 
-        public static AlternativeName? GetAlternativeNames(long? Id)
+        public static AlternativeName? GetAlternativeNames(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<AlternativeName> RetVal = _GetAlternativeNames(SearchUsing.id, Id);
-                return RetVal.Result;
+                AlternativeName? RetVal = Metadata.GetMetadata<AlternativeName>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static AlternativeName GetAlternativeNames(string Slug)
-        {
-            Task<AlternativeName> RetVal = _GetAlternativeNames(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<AlternativeName> _GetAlternativeNames(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("AlternativeName", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("AlternativeName", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            AlternativeName returnValue = new AlternativeName();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<AlternativeName>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<AlternativeName>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<AlternativeName> GetObjectFromServer(string WhereClause)
-        {
-            // get AlternativeNames metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<AlternativeName>(IGDBClient.Endpoints.AlternativeNames, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Artworks.cs

@@ -1,19 +1,17 @@
 using System;
-using IGDB;
-using IGDB.Models;
-
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Artworks
     {
-        const string fieldList = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;";
+        public const string fieldList = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;";
 
         public Artworks()
         {
         }
 
-        public static Artwork? GetArtwork(long? Id, string ImagePath, bool GetImages)
+        public static Artwork? GetArtwork(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,105 +19,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Artwork> RetVal = _GetArtwork(SearchUsing.id, Id, ImagePath, GetImages);
-                return RetVal.Result;
+                Artwork? RetVal = Metadata.GetMetadata<Artwork>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static Artwork GetArtwork(string Slug, string ImagePath, bool GetImages)
-        {
-            Task<Artwork> RetVal = _GetArtwork(SearchUsing.slug, Slug, ImagePath, GetImages);
-            return RetVal.Result;
-        }
-
-        private static async Task<Artwork> _GetArtwork(SearchUsing searchUsing, object searchValue, string ImagePath, bool GetImages = true)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Artwork", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Artwork", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Artwork returnValue = new Artwork();
-            bool forceImageDownload = false;
-            ImagePath = Path.Combine(ImagePath, "Artwork");
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                    Storage.NewCacheValue(returnValue);
-                    forceImageDownload = true;
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Artwork>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Artwork>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            // check for presence of "original" quality file - download if absent or force download is true
-            string localFile = Path.Combine(ImagePath, Communications.IGDBAPI_ImageSize.original.ToString(), returnValue.ImageId + ".jpg");
-            if (GetImages == true)
-            {
-                if ((!File.Exists(localFile)) || forceImageDownload == true)
-                {
-                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Artwork download forced.");
-
-                    Communications comms = new Communications();
-                    comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
-                }
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Artwork> GetObjectFromServer(string WhereClause, string ImagePath)
-        {
-            // get Artwork metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Artwork>(IGDBClient.Endpoints.Artworks, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Collections.cs

@@ -1,19 +1,17 @@
 using System;
-using IGDB;
-using IGDB.Models;
-
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Collections
     {
-        const string fieldList = "fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;";
+        public const string fieldList = "fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;";
 
         public Collections()
         {
         }
 
-        public static Collection? GetCollections(long? Id)
+        public static Collection? GetCollections(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +19,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Collection> RetVal = _GetCollections(SearchUsing.id, Id);
-                return RetVal.Result;
+                Collection? RetVal = Metadata.GetMetadata<Collection>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static Collection GetCollections(string Slug)
-        {
-            Task<Collection> RetVal = _GetCollections(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<Collection> _GetCollections(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Collection", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Collection", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Collection returnValue = new Collection();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Collection>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Collection>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Collection> GetObjectFromServer(string WhereClause)
-        {
-            // get Collections metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Collection>(IGDBClient.Endpoints.Collections, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Company.cs

@@ -1,18 +1,17 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Companies
     {
-        const string fieldList = "fields change_date,change_date_category,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;";
+        public const string fieldList = "fields change_date,change_date_category,changed_company_id,checksum,country,created_at,description,developed,logo,name,parent,published,slug,start_date,start_date_category,updated_at,url,websites;";
 
         public Companies()
         {
         }
 
-        public static Company? GetCompanies(long? Id)
+        public static Company? GetCompanies(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -20,105 +19,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Company> RetVal = _GetCompanies(SearchUsing.id, Id);
-                return RetVal.Result;
+                Company? RetVal = Metadata.GetMetadata<Company>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static Company GetCompanies(string Slug)
-        {
-            Task<Company> RetVal = _GetCompanies(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<Company> _GetCompanies(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Company", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Company", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Company returnValue = new Company();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    if (returnValue != null) { Storage.NewCacheValue(returnValue); }
-                    UpdateSubClasses(returnValue);
-                    break;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Company>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Company>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private static void UpdateSubClasses(Company company)
-        {
-            if (company.Logo != null)
-            {
-                CompanyLogo companyLogo = CompanyLogos.GetCompanyLogo(company.Logo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Company(company));
-            }
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Company> GetObjectFromServer(string WhereClause)
-        {
-            // get Companies metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Company>(IGDBClient.Endpoints.Companies, fieldList, WhereClause);
-            if (results.Length > 0)
-            {
-                var result = results.First();
-
-                return result;
-            }
-            else
-            {
-                return null;
-            }
-            
-        }
     }
 }
 

gaseous-server/Classes/Metadata/CompanyLogos.cs

@@ -1,13 +1,11 @@
 using System;
-using IGDB;
-using IGDB.Models;
-
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class CompanyLogos
     {
-        const string fieldList = "fields alpha_channel,animated,checksum,height,image_id,url,width;";
+        public const string fieldList = "fields alpha_channel,animated,checksum,height,image_id,url,width;";
 
         public CompanyLogos()
         {
@@ -21,104 +19,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<CompanyLogo> RetVal = _GetCompanyLogo(SearchUsing.id, Id, ImagePath);
-                return RetVal.Result;
+                CompanyLogo? RetVal = Metadata.GetMetadata<CompanyLogo>((long)Id, false);
+                return RetVal;
             }
         }
-
-        public static CompanyLogo GetCompanyLogo(string Slug, string ImagePath)
-        {
-            Task<CompanyLogo> RetVal = _GetCompanyLogo(SearchUsing.slug, Slug, ImagePath);
-            return RetVal.Result;
-        }
-
-        private static async Task<CompanyLogo> _GetCompanyLogo(SearchUsing searchUsing, object searchValue, string ImagePath)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("CompanyLogo", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("CompanyLogo", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            CompanyLogo returnValue = new CompanyLogo();
-            bool forceImageDownload = false;
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                    if (returnValue != null)
-                    {
-                        Storage.NewCacheValue(returnValue);
-                        forceImageDownload = true;
-                    }
-                    break;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<CompanyLogo>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<CompanyLogo>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            // check for presence of "original" quality file - download if absent or force download is true
-            string localFile = Path.Combine(ImagePath, Communications.IGDBAPI_ImageSize.original.ToString(), returnValue.ImageId + ".jpg");
-            if ((!File.Exists(localFile)) || forceImageDownload == true)
-            {
-                Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Company logo download forced.");
-
-                Communications comms = new Communications();
-                comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<CompanyLogo> GetObjectFromServer(string WhereClause, string ImagePath)
-        {
-            // get Artwork metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<CompanyLogo>(IGDBClient.Endpoints.CompanyLogos, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Covers.cs

@@ -1,21 +1,17 @@
 using System;
-using System.Net;
-using IGDB;
-using IGDB.Models;
-using Microsoft.CodeAnalysis.Elfie.Model.Strings;
-
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Covers
     {
-        const string fieldList = "fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;";
+        public const string fieldList = "fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;";
 
         public Covers()
         {
         }
 
-        public static Cover? GetCover(long? Id, string ImagePath, bool GetImages)
+        public static Cover? GetCover(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -23,118 +19,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Cover> RetVal = _GetCover(SearchUsing.id, Id, ImagePath, GetImages);
-                return RetVal.Result;
-            }
-        }
-
-        public static Cover GetCover(string Slug, string ImagePath, bool GetImages)
-        {
-            Task<Cover> RetVal = _GetCover(SearchUsing.slug, Slug, ImagePath, GetImages);
-            return RetVal.Result;
-        }
-
-        private static async Task<Cover> _GetCover(SearchUsing searchUsing, object searchValue, string ImagePath, bool GetImages = true)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Cover", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Cover", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Cover returnValue = new Cover();
-            bool forceImageDownload = false;
-            ImagePath = Path.Combine(ImagePath, "Covers");
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                    Storage.NewCacheValue(returnValue);
-                    forceImageDownload = true;
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Cover>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Cover>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            string localFile = Path.Combine(ImagePath, Communications.IGDBAPI_ImageSize.original.ToString(), returnValue.ImageId + ".jpg");
-            if (GetImages == true)
-            {
-                if ((!File.Exists(localFile)) || forceImageDownload == true)
-                {
-                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Cover download forced.");
-
-                    // check for presence of image file - download if absent or force download is true
-                    List<Communications.IGDBAPI_ImageSize> imageSizes = new List<Communications.IGDBAPI_ImageSize>{
-                        Communications.IGDBAPI_ImageSize.cover_big,
-                        Communications.IGDBAPI_ImageSize.cover_small,
-                        Communications.IGDBAPI_ImageSize.original
-                    };
-
-                    Communications comms = new Communications();
-                    foreach (Communications.IGDBAPI_ImageSize size in imageSizes)
-                    {
-                        localFile = Path.Combine(ImagePath, size.ToString(), returnValue.ImageId + ".jpg");
-                        if ((!File.Exists(localFile)) || forceImageDownload == true)
-                        {
-                            comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, size, null);
+                Cover? RetVal = Metadata.GetMetadata<Cover>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
     }
 }
 
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Cover> GetObjectFromServer(string WhereClause, string ImagePath)
-        {
-            // get Cover metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Cover>(IGDBClient.Endpoints.Covers, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
-	}
-}
-

gaseous-server/Classes/Metadata/ExternalGames.cs

@@ -1,19 +1,17 @@
 using System;
-using IGDB;
-using IGDB.Models;
-
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class ExternalGames
     {
-        const string fieldList = "fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;";
+        public const string fieldList = "fields category,checksum,countries,created_at,game,media,name,platform,uid,updated_at,url,year;";
 
         public ExternalGames()
         {
         }
 
-        public static ExternalGame? GetExternalGames(long? Id)
+        public static ExternalGame? GetExternalGames(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,96 +19,8 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<ExternalGame> RetVal = _GetExternalGames(SearchUsing.id, Id);
-                return RetVal.Result;
-            }
-        }
-
-        public static ExternalGame GetExternalGames(string Slug)
-        {
-            Task<ExternalGame> RetVal = _GetExternalGames(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<ExternalGame> _GetExternalGames(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("ExternalGame", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("ExternalGame", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            ExternalGame returnValue = new ExternalGame();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    if (returnValue != null)
-                    {
-                        Storage.NewCacheValue(returnValue);
-                    }
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<ExternalGame>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<ExternalGame>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<ExternalGame?> GetObjectFromServer(string WhereClause)
-        {
-            // get ExternalGames metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<ExternalGame>(IGDBClient.Endpoints.ExternalGames, fieldList, WhereClause);
-            if (results.Length > 0)
-            {
-                var result = results.First();
-
-                return result;
-            }
-            else
-            {
-                return null;
+                ExternalGame? RetVal = Metadata.GetMetadata<ExternalGame>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
     }

gaseous-server/Classes/Metadata/Franchises.cs

@@ -1,19 +1,17 @@
 using System;
-using IGDB;
-using IGDB.Models;
-
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Franchises
     {
-        const string fieldList = "fields checksum,created_at,games,name,slug,updated_at,url;";
+        public const string fieldList = "fields checksum,created_at,games,name,slug,updated_at,url;";
 
         public Franchises()
         {
         }
 
-        public static Franchise? GetFranchises(long? Id)
+        public static Franchise? GetFranchises(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +19,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Franchise> RetVal = _GetFranchises(SearchUsing.id, Id);
-                return RetVal.Result;
+                Franchise? RetVal = Metadata.GetMetadata<Franchise>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static Franchise GetFranchises(string Slug)
-        {
-            Task<Franchise> RetVal = _GetFranchises(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<Franchise> _GetFranchises(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Franchise", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Franchise", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Franchise returnValue = new Franchise();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Franchise>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Franchise>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Franchise> GetObjectFromServer(string WhereClause)
-        {
-            // get FranchiseContentDescriptions metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Franchise>(IGDBClient.Endpoints.Franchies, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/GameModes.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class GameModes
     {
-        const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
+        public const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
 
         public GameModes()
         {
         }
 
-        public static GameMode? GetGame_Modes(long? Id)
+        public static GameMode? GetGame_Modes(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<GameMode> RetVal = _GetGame_Modes(SearchUsing.id, Id);
-                return RetVal.Result;
+                GameMode? RetVal = Metadata.GetMetadata<GameMode>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static GameMode GetGame_Modes(string Slug)
-        {
-            Task<GameMode> RetVal = _GetGame_Modes(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<GameMode> _GetGame_Modes(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("GameMode", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("GameMode", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            GameMode returnValue = new GameMode();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<GameMode>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<GameMode>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<GameMode> GetObjectFromServer(string WhereClause)
-        {
-            // get Game_Modes metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<GameMode>(IGDBClient.Endpoints.GameModes, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/GameVideos.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class GamesVideos
     {
-        const string fieldList = "fields checksum,game,name,video_id;";
+        public const string fieldList = "fields checksum,game,name,video_id;";
 
         public GamesVideos()
         {
         }
 
-        public static GameVideo? GetGame_Videos(long? Id)
+        public static GameVideo? GetGame_Videos(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<GameVideo> RetVal = _GetGame_Videos(SearchUsing.id, Id);
-                return RetVal.Result;
+                GameVideo? RetVal = Metadata.GetMetadata<GameVideo>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static GameVideo GetGame_Videos(string Slug)
-        {
-            Task<GameVideo> RetVal = _GetGame_Videos(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<GameVideo> _GetGame_Videos(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("GameVideo", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("GameVideo", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            GameVideo returnValue = new GameVideo();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<GameVideo>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<GameVideo>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<GameVideo> GetObjectFromServer(string WhereClause)
-        {
-            // get Game_Videos metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<GameVideo>(IGDBClient.Endpoints.GameVideos, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Games.cs

@@ -1,13 +1,13 @@
 using System;
 using System.Data;
-using IGDB;
-using IGDB.Models;
+using System.Security.Cryptography.X509Certificates;
+using gaseous_server.Models;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Games
     {
-        const string fieldList = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collection,collections,cover,created_at,dlcs,expanded_games,expansions,external_games,first_release_date,follows,forks,franchise,franchises,game_engines,game_localizations,game_modes,genres,hypes,involved_companies,keywords,language_supports,multiplayer_modes,name,parent_game,platforms,player_perspectives,ports,rating,rating_count,release_dates,remakes,remasters,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;";
+        public const string fieldList = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collections,cover,created_at,dlcs,expanded_games,expansions,external_games,first_release_date,follows,forks,franchise,franchises,game_engines,game_localizations,game_modes,genres,hypes,involved_companies,keywords,language_supports,multiplayer_modes,name,parent_game,platforms,player_perspectives,ports,rating,rating_count,release_dates,remakes,remasters,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;";
 
         public Games()
         {
@@ -20,39 +20,32 @@ namespace gaseous_server.Classes.Metadata
             { }
         }
 
-        public static Game? GetGame(long Id, bool getAllMetadata, bool followSubGames, bool forceRefresh)
+        public static Game? GetGame(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
-            if (Id == 0)
+            if ((Id == 0) || (Id == null))
             {
-                Game returnValue = new Game();
-                if (Storage.GetCacheStatus("Game", 0) == Storage.CacheStatus.NotPresent)
-                {
-                    returnValue = new Game
-                    {
-                        Id = 0,
-                        Name = "Unknown Title",
-                        Slug = "Unknown"
-                    };
-                    Storage.NewCacheValue(returnValue);
-
-                    return returnValue;
+                return null;
             }
             else
             {
-                    return Storage.GetCacheValue<Game>(returnValue, "id", 0);
-                }
-            }
-            else
+                Game? RetVal = Metadata.GetMetadata<Game>(SourceType, (long)Id, false);
+                RetVal.MetadataSource = SourceType;
+                long? metadataMap = MetadataManagement.GetMetadataMapIdFromSourceId(SourceType, (long)Id);
+                if (metadataMap != null)
                 {
-                Task<Game> RetVal = _GetGame(SearchUsing.id, Id, getAllMetadata, followSubGames, forceRefresh);
-                return RetVal.Result;
+                    RetVal.MetadataMapId = (long)metadataMap;
+                }
+                RetVal = MassageResult(RetVal);
+                return RetVal;
             }
         }
 
-        public static Game GetGame(string Slug, bool getAllMetadata, bool followSubGames, bool forceRefresh)
+        public static Game? GetGame(HasheousClient.Models.MetadataSources SourceType, string? Slug)
         {
-            Task<Game> RetVal = _GetGame(SearchUsing.slug, Slug, getAllMetadata, followSubGames, forceRefresh);
-            return RetVal.Result;
+            Game? RetVal = Metadata.GetMetadata<Game>(SourceType, Slug, false);
+            RetVal.MetadataSource = SourceType;
+            RetVal = MassageResult(RetVal);
+            return RetVal;
         }
 
         public static Game GetGame(DataRow dataRow)
@@ -60,325 +53,43 @@ namespace gaseous_server.Classes.Metadata
             return Storage.BuildCacheObject<Game>(new Game(), dataRow);
         }
 
-        private static async Task<Game> _GetGame(SearchUsing searchUsing, object searchValue, bool getAllMetadata = true, bool followSubGames = false, bool forceRefresh = false)
+        private static Game MassageResult(Game result)
         {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Game", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Game", (string)searchValue);
-            }
-
-            if (forceRefresh == true)
-            {
-                if (cacheStatus == Storage.CacheStatus.Current) { cacheStatus = Storage.CacheStatus.Expired; }
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Game returnValue = new Game();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    UpdateSubClasses(returnValue, getAllMetadata, followSubGames, forceRefresh);
-                    return returnValue;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(returnValue, getAllMetadata, followSubGames, forceRefresh);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
-                    }
-                    return returnValue;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
-                    UpdateSubClasses(returnValue, false, false, false);
-                    return returnValue;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-        }
-
-        private static void UpdateSubClasses(Game Game, bool getAllMetadata, bool followSubGames, bool forceRefresh)
-        {
-            // required metadata
-            if (Game.Cover != null)
-            {
-                try
-                {
-                    Cover GameCover = Covers.GetCover(Game.Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch cover artwork.", ex);
-                }
-            }
-
-            if (Game.Genres != null)
-            {
-                foreach (long GenreId in Game.Genres.Ids)
-                {
-                    Genre GameGenre = Genres.GetGenres(GenreId);
-                }
-            }
-
-            if (Game.GameModes != null)
-            {
-                foreach (long gameModeId in Game.GameModes.Ids)
-                {
-                    GameMode gameMode = GameModes.GetGame_Modes(gameModeId);
-                }
-            }
-
-            if (Game.MultiplayerModes != null)
-            {
-                foreach (long multiplayerModeId in Game.MultiplayerModes.Ids)
-                {
-                    MultiplayerMode multiplayerMode = MultiplayerModes.GetGame_MultiplayerModes(multiplayerModeId);
-                }
-            }
-
-            if (Game.PlayerPerspectives != null)
-            {
-                foreach (long PerspectiveId in Game.PlayerPerspectives.Ids)
-                {
-                    PlayerPerspective GamePlayPerspective = PlayerPerspectives.GetGame_PlayerPerspectives(PerspectiveId);
-                }
-            }
-
-            if (Game.Themes != null)
-            {
-                foreach (long ThemeId in Game.Themes.Ids)
-                {
-                    Theme GameTheme = Themes.GetGame_Themes(ThemeId);
-                }
-            }
-
-            if (Game.AgeRatings != null)
-            {
-                foreach (long AgeRatingId in Game.AgeRatings.Ids)
-                {
-                    AgeRating GameAgeRating = AgeRatings.GetAgeRatings(AgeRatingId);
-                }
-            }
-            AgeGroups.GetAgeGroup(Game);
-
-            if (Game.ReleaseDates != null)
-            {
-                foreach (long ReleaseDateId in Game.ReleaseDates.Ids)
-                {
-                    ReleaseDate GameReleaseDate = ReleaseDates.GetReleaseDates(ReleaseDateId);
-                }
-            }
-
-            // optional metadata - usually downloaded as needed
-            if (getAllMetadata == true)
-            {
-                if (Game.AlternativeNames != null)
-                {
-                    foreach (long AlternativeNameId in Game.AlternativeNames.Ids)
-                    {
-                        AlternativeName GameAlternativeName = AlternativeNames.GetAlternativeNames(AlternativeNameId);
-                    }
-                }
-
-                if (Game.Artworks != null)
-                {
-                    foreach (long ArtworkId in Game.Artworks.Ids)
-                    {
-                        try
-                        {
-                            Artwork GameArtwork = Artworks.GetArtwork(ArtworkId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
-                        }
-                        catch (Exception ex)
-                        {
-                            Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch artwork id: " + ArtworkId, ex);
-                        }
-                    }
-                }
-
-                if (followSubGames)
-                {
-                    List<long> gamesToFetch = new List<long>();
-                    if (Game.Bundles != null) { gamesToFetch.AddRange(Game.Bundles.Ids); }
-                    if (Game.Dlcs != null) { gamesToFetch.AddRange(Game.Dlcs.Ids); }
-                    if (Game.Expansions != null) { gamesToFetch.AddRange(Game.Expansions.Ids); }
-                    if (Game.ParentGame != null) { gamesToFetch.Add((long)Game.ParentGame.Id); }
-                    //if (Game.SimilarGames != null) { gamesToFetch.AddRange(Game.SimilarGames.Ids); }
-                    if (Game.StandaloneExpansions != null) { gamesToFetch.AddRange(Game.StandaloneExpansions.Ids); }
-                    if (Game.VersionParent != null) { gamesToFetch.Add((long)Game.VersionParent.Id); }
-
-                    foreach (long gameId in gamesToFetch)
-                    {
-                        Game relatedGame = GetGame(gameId, false, true, false);
-                    }
-                }
-
-                if (Game.Collection != null)
-                {
-                    Collection GameCollection = Collections.GetCollections(Game.Collection.Id);
-                }
-
-                if (Game.ExternalGames != null)
-                {
-                    foreach (long ExternalGameId in Game.ExternalGames.Ids)
-                    {
-                        ExternalGame GameExternalGame = ExternalGames.GetExternalGames(ExternalGameId);
-                    }
-                }
-
-                if (Game.Franchise != null)
-                {
-                    Franchise GameFranchise = Franchises.GetFranchises(Game.Franchise.Id);
-                }
-
-                if (Game.Franchises != null)
-                {
-                    foreach (long FranchiseId in Game.Franchises.Ids)
-                    {
-                        Franchise GameFranchise = Franchises.GetFranchises(FranchiseId);
-                    }
-                }
-
-                if (Game.InvolvedCompanies != null)
-                {
-                    foreach (long involvedCompanyId in Game.InvolvedCompanies.Ids)
-                    {
-                        InvolvedCompany involvedCompany = InvolvedCompanies.GetInvolvedCompanies(involvedCompanyId);
-                    }
-                }
-
-                if (Game.Platforms != null)
-                {
-                    foreach (long PlatformId in Game.Platforms.Ids)
-                    {
-                        Platform GamePlatform = Platforms.GetPlatform(PlatformId);
-                    }
-                }
-
-                if (Game.Screenshots != null)
-                {
-                    foreach (long ScreenshotId in Game.Screenshots.Ids)
-                    {
-                        try
-                        {
-                        Screenshot GameScreenshot = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
-                        }
-                        catch (Exception ex)
-                        {
-                            Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch screenshot id: " + ScreenshotId, ex);
-                        }
-                    }
-                }
-
-                if (Game.Videos != null)
-                {
-                    foreach (long GameVideoId in Game.Videos.Ids)
-                    {
-                        GameVideo gameVideo = GamesVideos.GetGame_Videos(GameVideoId);
-                    }
-                }
-            }
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Game> GetObjectFromServer(string WhereClause)
-        {
-            // get Game metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Game>(IGDBClient.Endpoints.Games, fieldList, WhereClause);
-            var result = results.First();
-
-            // add artificial unknown platform mapping
-            List<long> platformIds = new List<long>();
-            platformIds.Add(0);
-            if (result.Platforms != null)
-            {
-                if (result.Platforms.Ids != null)
-                {
-                    platformIds.AddRange(result.Platforms.Ids.ToList());
-                }
-            }
-            result.Platforms = new IdentitiesOrValues<Platform>(
-                ids: platformIds.ToArray<long>()
-            );
+            Game? parentGame = null;
 
             // get cover art from parent if this has no cover
             if (result.Cover == null)
             {
                 if (result.ParentGame != null)
-                {
-                    if (result.ParentGame.Id != null)
                 {
                     Logging.Log(Logging.LogType.Information, "Game Metadata", "Game has no cover art, fetching cover art from parent game");
-                        Game parentGame = GetGame((long)result.ParentGame.Id, false, false, false);
+                    parentGame = GetGame(result.MetadataSource, (long)result.ParentGame);
                     result.Cover = parentGame.Cover;
                 }
             }
-            }
 
             // get missing metadata from parent if this is a port
-            if (result.Category == Category.Port)
+            if (result.Category == HasheousClient.Models.Metadata.IGDB.Category.Port)
             {
                 if (result.Summary == null)
                 {
                     if (result.ParentGame != null)
-                    {
-                        if (result.ParentGame.Id != null)
                     {
                         Logging.Log(Logging.LogType.Information, "Game Metadata", "Game has no summary, fetching summary from parent game");
-                            Game parentGame = GetGame((long)result.ParentGame.Id, false, false, false);
                         result.Summary = parentGame.Summary;
                     }
                 }
             }
+
+            // populate age group data
+            if (result.MetadataSource == HasheousClient.Models.MetadataSources.IGDB)
+            {
+                AgeGroups.GetAgeGroup(result);
             }
 
             return result;
         }
 
-        public static void AssignAllGamesToPlatformIdZero()
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT * FROM Game;";
-            DataTable gamesTable = db.ExecuteCMD(sql);
-            foreach (DataRow gameRow in gamesTable.Rows)
-            {
-                sql = "DELETE FROM Relation_Game_Platforms WHERE PlatformsId = 0 AND GameId = @Id; INSERT INTO Relation_Game_Platforms (GameId, PlatformsId) VALUES (@Id, 0);";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("Id", (long)gameRow["Id"]);
-                db.ExecuteCMD(sql, dbDict);
-            }
-        }
-
         private static bool AllowNoPlatformSearch = false;
 
         public static Game[] SearchForGame(string SearchString, long PlatformId, SearchType searchType)
@@ -427,7 +138,7 @@ namespace gaseous_server.Classes.Metadata
                     break;
             }
 
-            string sql = "SELECT Game.Id, Game.`Name`, Game.Slug, Relation_Game_Platforms.PlatformsId AS PlatformsId, Game.Summary FROM gaseous.Game JOIN Relation_Game_Platforms ON Game.Id = Relation_Game_Platforms.GameId WHERE " + whereClause + ";";
+            string sql = "SELECT Game.Id, Game.`Name`, Game.Slug, Relation_Game_Platforms.PlatformsId AS PlatformsId, Game.Summary FROM gaseous.Game JOIN Relation_Game_Platforms ON Game.Id = Relation_Game_Platforms.GameId AND Game.SourceId = Relation_Game_Platforms.GameSourceId WHERE " + whereClause + ";";
 
 
             // get Game metadata
@@ -439,7 +150,8 @@ namespace gaseous_server.Classes.Metadata
                 DataTable data = db.ExecuteCMD(sql, dbDict);
                 foreach (DataRow row in data.Rows)
                 {
-                    Game game = new Game{
+                    Game game = new Game
+                    {
                         Id = (long)row["Id"],
                         Name = (string)Common.ReturnValueIfNull(row["Name"], ""),
                         Slug = (string)Common.ReturnValueIfNull(row["Slug"], ""),
@@ -455,6 +167,13 @@ namespace gaseous_server.Classes.Metadata
         }
 
         private static async Task<Game[]> _SearchForGameRemote(string SearchString, long PlatformId, SearchType searchType)
+        {
+            switch (Config.MetadataConfiguration.DefaultMetadataSource)
+            {
+                case HasheousClient.Models.MetadataSources.None:
+                    return new Game[0];
+                case HasheousClient.Models.MetadataSources.IGDB:
+                    if (Config.IGDB.UseHasheousProxy == false)
                     {
                         string searchBody = "";
                         string searchFields = "fields id,name,slug,platforms,summary; ";
@@ -488,7 +207,7 @@ namespace gaseous_server.Classes.Metadata
                             Game[]? results = new Game[0];
                             if (allowSearch == true)
                             {
-                    results = await comms.APIComm<Game>(IGDBClient.Endpoints.Games, searchFields, searchBody);
+                                results = await comms.APIComm<Game>(IGDB.IGDBClient.Endpoints.Games, searchFields, searchBody);
 
                                 Communications.SetSearchCache<Game[]?>(searchFields, searchBody, results);
                             }
@@ -500,25 +219,212 @@ namespace gaseous_server.Classes.Metadata
                             return games.ToArray();
                         }
                     }
+                    else
+                    {
+                        HasheousClient.Hasheous hasheous = new HasheousClient.Hasheous();
+                        HasheousClient.Models.Metadata.IGDB.Game[] hResults = hasheous.GetMetadataProxy_SearchGame<HasheousClient.Models.Metadata.IGDB.Game>(HasheousClient.Hasheous.MetadataProvider.IGDB, PlatformId.ToString(), SearchString);
 
-        public static List<KeyValuePair<long, string>> GetAvailablePlatforms(long GameId)
+                        List<Game> hGames = new List<Game>();
+                        foreach (HasheousClient.Models.Metadata.IGDB.Game hResult in hResults)
+                        {
+                            hGames.Add(Communications.ConvertToIGDBModel<Game>(hResult));
+                        }
+
+                        return hGames.ToArray();
+                    }
+                default:
+                    return new Game[0];
+            }
+        }
+
+        public static List<AvailablePlatformItem> GetAvailablePlatforms(string UserId, HasheousClient.Models.MetadataSources SourceType, long GameId)
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT DISTINCT Games_Roms.PlatformId, Platform.`Name` FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE Games_Roms.GameId = @gameid ORDER BY Platform.`Name`;";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("gameid", GameId);
+            string sql = @"
+SELECT DISTINCT
+	view_Games_Roms.MetadataMapId,
+    view_Games_Roms.GameId,
+    view_Games_Roms.PlatformId,
+    view_Games_Roms.UserManualLink,
+    Platform.`Name`,
+    User_RecentPlayedRoms.UserId AS MostRecentUserId,
+    User_RecentPlayedRoms.RomId AS MostRecentRomId,
+    CASE User_RecentPlayedRoms.IsMediaGroup
+        WHEN 0 THEN GMR.`Name`
+        WHEN 1 THEN view_Games_Roms.`MetadataGameName`
+        ELSE NULL
+    END AS `MostRecentRomName`,
+    User_RecentPlayedRoms.IsMediaGroup AS MostRecentRomIsMediaGroup,
+    User_GameFavouriteRoms.UserId AS FavouriteUserId,
+    User_GameFavouriteRoms.RomId AS FavouriteRomId,
+    CASE User_GameFavouriteRoms.IsMediaGroup
+        WHEN 0 THEN GFV.`Name`
+        WHEN 1 THEN view_Games_Roms.`MetadataGameName`
+        ELSE NULL
+    END AS `FavouriteRomName`,
+    User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup
+FROM
+    view_Games_Roms
+        LEFT JOIN
+    Platform ON view_Games_Roms.PlatformId = Platform.Id AND Platform.SourceId = view_Games_Roms.GameIdType
+        LEFT JOIN
+    User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
+        AND User_RecentPlayedRoms.GameId = view_Games_Roms.MetadataMapId
+        AND User_RecentPlayedRoms.PlatformId = view_Games_Roms.PlatformId
+        LEFT JOIN
+    User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
+        AND User_GameFavouriteRoms.GameId = view_Games_Roms.MetadataMapId
+        AND User_GameFavouriteRoms.PlatformId = view_Games_Roms.PlatformId
+        LEFT JOIN
+    view_Games_Roms AS GMR ON GMR.Id = User_RecentPlayedRoms.RomId
+        LEFT JOIN
+    view_Games_Roms AS GFV ON GFV.Id = User_GameFavouriteRoms.RomId
+WHERE
+    view_Games_Roms.GameIdType = @sourcetype AND view_Games_Roms.GameId = @gameid
+ORDER BY Platform.`Name`;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "sourcetype", (int)SourceType },
+                { "gameid", GameId },
+                { "userid", UserId }
+            };
             DataTable data = db.ExecuteCMD(sql, dbDict);
 
-            List<KeyValuePair<long, string>> platforms = new List<KeyValuePair<long, string>>();
+            PlatformMapping platformMapping = new PlatformMapping();
+            List<AvailablePlatformItem> platforms = new List<AvailablePlatformItem>();
             foreach (DataRow row in data.Rows)
             {
-                KeyValuePair<long, string> valuePair = new KeyValuePair<long, string>((long)row["PlatformId"], (string)row["Name"]);
+                HasheousClient.Models.Metadata.IGDB.Platform platform = Platforms.GetPlatform((long)row["PlatformId"]);
+
+                // get the user emulator configuration
+                PlatformMapping.UserEmulatorConfiguration? emulatorConfiguration = platformMapping.GetUserEmulator(UserId, GameId, (long)platform.Id);
+
+                // if no user configuration, get the platform emulator configuration
+                if (emulatorConfiguration == null)
+                {
+                    if (platform.Id != 0)
+                    {
+                        Models.PlatformMapping.PlatformMapItem platformMap = PlatformMapping.GetPlatformMap((long)platform.Id);
+                        if (platformMap != null)
+                        {
+                            emulatorConfiguration = new PlatformMapping.UserEmulatorConfiguration
+                            {
+                                EmulatorType = platformMap.WebEmulator.Type,
+                                Core = platformMap.WebEmulator.Core,
+                                EnableBIOSFiles = platformMap.EnabledBIOSHashes
+                            };
+                        }
+                    }
+                }
+
+                // if still no emulator configuration, create a blank one
+                if (emulatorConfiguration == null)
+                {
+                    emulatorConfiguration = new PlatformMapping.UserEmulatorConfiguration
+                    {
+                        EmulatorType = "",
+                        Core = "",
+                        EnableBIOSFiles = new List<string>()
+                    };
+                }
+
+                long? LastPlayedRomId = null;
+                bool? LastPlayedIsMediagroup = false;
+                string? LastPlayedRomName = null;
+                if (row["MostRecentRomId"] != DBNull.Value)
+                {
+                    LastPlayedRomId = (long?)row["MostRecentRomId"];
+                    LastPlayedIsMediagroup = (bool)row["MostRecentRomIsMediaGroup"];
+                    if (row["MostRecentRomName"] != System.DBNull.Value)
+                    {
+                        LastPlayedRomName = string.IsNullOrEmpty((string?)row["MostRecentRomName"]) ? "" : (string)row["MostRecentRomName"];
+                    }
+                }
+
+                long? FavouriteRomId = null;
+                bool? FavouriteRomIsMediagroup = false;
+                string? FavouriteRomName = null;
+                if (row["FavouriteRomId"] != DBNull.Value)
+                {
+                    FavouriteRomId = (long?)row["FavouriteRomId"];
+                    FavouriteRomIsMediagroup = (bool)row["FavouriteRomIsMediaGroup"];
+                    if (row["FavouriteRomName"] != System.DBNull.Value)
+                    {
+                        FavouriteRomName = string.IsNullOrEmpty((string?)row["FavouriteRomName"]) ? "" : (string)row["FavouriteRomName"];
+                    }
+                }
+
+                string? UserManualLink = null;
+                if (row["UserManualLink"] != DBNull.Value)
+                {
+                    UserManualLink = string.IsNullOrEmpty((string?)row["UserManualLink"]) ? "" : (string)row["UserManualLink"];
+                }
+
+                AvailablePlatformItem valuePair = new AvailablePlatformItem
+                {
+                    Id = platform.Id,
+                    Name = platform.Name,
+                    MetadataMapId = (long)row["MetadataMapId"],
+                    Category = platform.Category,
+                    emulatorConfiguration = emulatorConfiguration,
+                    LastPlayedRomId = LastPlayedRomId,
+                    LastPlayedRomIsMediagroup = LastPlayedIsMediagroup,
+                    LastPlayedRomName = LastPlayedRomName,
+                    FavouriteRomId = FavouriteRomId,
+                    FavouriteRomIsMediagroup = FavouriteRomIsMediagroup,
+                    FavouriteRomName = FavouriteRomName,
+                    UserManualLink = UserManualLink
+                };
                 platforms.Add(valuePair);
             }
 
+            // sort platforms by the Name attribute
+            platforms.Sort((x, y) => x.Name.CompareTo(y.Name));
+
             return platforms;
         }
 
+        public static void GameSetFavouriteRom(string UserId, long GameId, long PlatformId, long RomId, bool IsMediaGroup)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM User_GameFavouriteRoms WHERE UserId = @userid AND GameId = @gameid AND PlatformId = @platformid; INSERT INTO User_GameFavouriteRoms (UserId, GameId, PlatformId, RomId, IsMediaGroup) VALUES (@userid, @gameid, @platformid, @romid, @ismediagroup);";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "userid", UserId },
+                { "gameid", GameId },
+                { "platformid", PlatformId },
+                { "romid", RomId },
+                { "ismediagroup", IsMediaGroup }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public static void GameClearFavouriteRom(string UserId, long GameId, long PlatformId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM User_GameFavouriteRoms WHERE UserId = @userid AND GameId = @gameid AND PlatformId = @platformid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "userid", UserId },
+                { "gameid", GameId },
+                { "platformid", PlatformId }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public class AvailablePlatformItem : HasheousClient.Models.Metadata.IGDB.Platform
+        {
+            public long MetadataMapId { get; set; }
+            public PlatformMapping.UserEmulatorConfiguration emulatorConfiguration { get; set; }
+            public long? LastPlayedRomId { get; set; }
+            public bool? LastPlayedRomIsMediagroup { get; set; }
+            public string? LastPlayedRomName { get; set; }
+            public long? FavouriteRomId { get; set; }
+            public bool? FavouriteRomIsMediagroup { get; set; }
+            public string? FavouriteRomName { get; set; }
+            public string? UserManualLink { get; set; }
+        }
+
         public enum SearchType
         {
             where = 0,
@@ -537,8 +443,10 @@ namespace gaseous_server.Classes.Metadata
             public MinimalGameItem(Game gameObject)
             {
                 this.Id = gameObject.Id;
+                this.MetadataMapId = gameObject.MetadataMapId;
                 this.Name = gameObject.Name;
                 this.Slug = gameObject.Slug;
+                this.Summary = gameObject.Summary;
                 this.TotalRating = gameObject.TotalRating;
                 this.TotalRatingCount = gameObject.TotalRatingCount;
                 this.Cover = gameObject.Cover;
@@ -546,12 +454,12 @@ namespace gaseous_server.Classes.Metadata
                 this.FirstReleaseDate = gameObject.FirstReleaseDate;
 
                 // compile age ratings
-                this.AgeRatings = new List<AgeRating>();
+                this.AgeRatings = new List<object>();
                 if (gameObject.AgeRatings != null)
                 {
-                    foreach (long ageRatingId in gameObject.AgeRatings.Ids)
+                    foreach (long ageRatingId in gameObject.AgeRatings)
                     {
-                        AgeRating? rating = Classes.Metadata.AgeRatings.GetAgeRatings(ageRatingId);
+                        HasheousClient.Models.Metadata.IGDB.AgeRating? rating = Classes.Metadata.AgeRatings.GetAgeRating(gameObject.MetadataSource, ageRatingId);
                         if (rating != null)
                         {
                             this.AgeRatings.Add(rating);
@@ -561,16 +469,19 @@ namespace gaseous_server.Classes.Metadata
             }
 
             public long? Id { get; set; }
+            public long? MetadataMapId { get; set; }
+            public long Index { get; set; }
             public string Name { get; set; }
             public string Slug { get; set; }
+            public string Summary { get; set; }
             public double? TotalRating { get; set; }
             public int? TotalRatingCount { get; set; }
             public bool HasSavedGame { get; set; } = false;
             public bool IsFavourite { get; set; } = false;
             public DateTimeOffset? FirstReleaseDate { get; set; }
-            public IGDB.IdentityOrValue<IGDB.Models.Cover> Cover { get; set; }
-            public IGDB.IdentitiesOrValues<IGDB.Models.Artwork> Artworks { get; set; }
-            public List<IGDB.Models.AgeRating> AgeRatings { get; set; }
+            public object Cover { get; set; }
+            public List<long> Artworks { get; set; }
+            public List<object> AgeRatings { get; set; }
         }
     }
 }

gaseous-server/Classes/Metadata/Genres.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Genres
     {
-        const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
+        public const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
 
         public Genres()
         {
         }
 
-        public static Genre? GetGenres(long? Id)
+        public static Genre? GetGenres(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Genre> RetVal = _GetGenres(SearchUsing.id, Id);
-                return RetVal.Result;
+                Genre? RetVal = Metadata.GetMetadata<Genre>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static Genre GetGenres(string Slug)
-        {
-            Task<Genre> RetVal = _GetGenres(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<Genre> _GetGenres(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Genre", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Genre", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Genre returnValue = new Genre();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Genre>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Genre>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Genre> GetObjectFromServer(string WhereClause)
-        {
-            // get Genres metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Genre>(IGDBClient.Endpoints.Genres, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/InvolvedCompany.cs

@@ -1,12 +1,11 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class InvolvedCompanies
     {
-        const string fieldList = "fields *;";
+        public const string fieldList = "fields *;";
 
         public InvolvedCompanies()
         {
@@ -20,106 +19,8 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<InvolvedCompany> RetVal = _GetInvolvedCompanies(SearchUsing.id, Id);
-                return RetVal.Result;
-            }
-        }
-
-        public static InvolvedCompany GetInvolvedCompanies(string Slug)
-        {
-            Task<InvolvedCompany> RetVal = _GetInvolvedCompanies(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<InvolvedCompany> _GetInvolvedCompanies(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("InvolvedCompany", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("InvolvedCompany", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            InvolvedCompany returnValue = new InvolvedCompany();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    UpdateSubClasses(returnValue);
-                    break;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<InvolvedCompany>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<InvolvedCompany>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private static void UpdateSubClasses(InvolvedCompany involvedCompany)
-        {
-            if (involvedCompany.Company != null)
-            {
-                Company company = Companies.GetCompanies(involvedCompany.Company.Id);
-            }
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<InvolvedCompany> GetObjectFromServer(string WhereClause)
-        {
-            // get InvolvedCompanies metadata
-            try
-            {
-                Communications comms = new Communications();
-            var results = await comms.APIComm<InvolvedCompany>(IGDBClient.Endpoints.InvolvedCompanies, fieldList, WhereClause);
-                var result = results.First();
-
-                return result;
-            }
-            catch (Exception ex)
-            {
-                Logging.Log(Logging.LogType.Critical, "Involved Companies", "Failure when requesting involved companies.");
-                Logging.Log(Logging.LogType.Critical, "Involved Companies", "Field list: " + fieldList);
-                Logging.Log(Logging.LogType.Critical, "Involved Companies", "Where clause: " + WhereClause);
-                Logging.Log(Logging.LogType.Critical, "Involved Companies", "Error", ex);
-                throw;
+                InvolvedCompany? RetVal = Metadata.GetMetadata<InvolvedCompany>(HasheousClient.Models.MetadataSources.IGDB, (long)Id, false);
+                return RetVal;
             }
         }
     }

gaseous-server/Classes/Metadata/Metadata.cs

@@ -0,0 +1,262 @@
+using System.Data;
+
+namespace gaseous_server.Classes.Metadata
+{
+    public class Metadata
+    {
+        #region Exception Handling
+        public class InvalidMetadataId : Exception
+        {
+            public InvalidMetadataId(long Id) : base("Invalid Metadata id: " + Id + " from source: " + HasheousClient.Models.MetadataSources.IGDB + " (default)")
+            {
+            }
+
+            public InvalidMetadataId(HasheousClient.Models.MetadataSources SourceType, long Id) : base("Invalid Metadata id: " + Id + " from source: " + SourceType)
+            {
+            }
+
+            public InvalidMetadataId(string Id) : base("Invalid Metadata id: " + Id + " from source: " + HasheousClient.Models.MetadataSources.IGDB + " (default)")
+            {
+            }
+
+            public InvalidMetadataId(HasheousClient.Models.MetadataSources SourceType, string Id) : base("Invalid Metadata id: " + Id + " from source: " + SourceType)
+            {
+            }
+        }
+        #endregion
+
+        #region Get Metadata
+        /// <summary>
+        /// Get metadata from the default source
+        /// </summary>
+        /// <typeparam name="T">
+        /// The type of metadata to get
+        /// </typeparam>
+        /// <param name="Id">
+        /// The id of the metadata to get
+        /// </param>
+        /// <returns>
+        /// The metadata object
+        /// </returns>
+        /// <exception cref="InvalidMetadataId">
+        /// Thrown when the id is invalid
+        /// </exception>
+        public static T? GetMetadata<T>(long Id, Boolean ForceRefresh = false) where T : class
+        {
+            if (Id < 0)
+            {
+                throw new InvalidMetadataId(Id);
+            }
+
+            return _GetMetadata<T>(HasheousClient.Models.MetadataSources.IGDB, Id, ForceRefresh);
+        }
+
+        /// <summary>
+        /// Get metadata from the specified source
+        /// </summary>
+        /// <typeparam name="T">
+        /// The type of metadata to get
+        /// </typeparam>
+        /// <param name="SourceType">
+        /// The source of the metadata
+        /// </param>
+        /// <param name="Id">
+        /// The id of the metadata to get
+        /// </param>
+        /// <returns>
+        /// The metadata object
+        /// </returns>
+        /// <exception cref="InvalidMetadataId">
+        /// Thrown when the id is invalid
+        /// </exception>
+        public static T? GetMetadata<T>(HasheousClient.Models.MetadataSources SourceType, long Id, Boolean ForceRefresh = false) where T : class
+        {
+            if (Id < 0)
+            {
+                throw new InvalidMetadataId(SourceType, Id);
+            }
+
+            return _GetMetadata<T>(SourceType, Id, ForceRefresh);
+        }
+
+        public static T? GetMetadata<T>(HasheousClient.Models.MetadataSources SourceType, string Slug, Boolean ForceRefresh = false) where T : class
+        {
+            return _GetMetadata<T>(SourceType, Slug, ForceRefresh);
+        }
+
+        private static T? _GetMetadata<T>(HasheousClient.Models.MetadataSources SourceType, object Id, Boolean ForceRefresh) where T : class
+        {
+            // get T type as string
+            string type = typeof(T).Name;
+
+            // get type of Id as string
+            IdType idType = Id.GetType() == typeof(long) ? IdType.Long : IdType.String;
+
+            // check cached metadata status
+            // if metadata is not cached or expired, get it from the source. Otherwise, return the cached metadata
+            Storage.CacheStatus? cacheStatus;
+            if (idType == IdType.Long)
+            {
+                cacheStatus = Storage.GetCacheStatus(SourceType, type, (long)Id);
+            }
+            else
+            {
+                cacheStatus = Storage.GetCacheStatus(SourceType, type, (string)Id);
+            }
+
+            // if ForceRefresh is true, set cache status to expired if it is current
+            if (ForceRefresh == true)
+            {
+                if (cacheStatus == Storage.CacheStatus.Current)
+                {
+                    cacheStatus = Storage.CacheStatus.Expired;
+                }
+            }
+
+            // if the source is "none", cache status should be "current" or "not present"
+            if (SourceType == HasheousClient.Models.MetadataSources.None)
+            {
+                if (cacheStatus == Storage.CacheStatus.Expired)
+                {
+                    cacheStatus = Storage.CacheStatus.Current;
+                }
+            }
+
+            T? metadata = (T)Activator.CreateInstance(typeof(T));
+
+            switch (cacheStatus)
+            {
+                case Storage.CacheStatus.Current:
+                    if (idType == IdType.Long)
+                    {
+                        metadata = Storage.GetCacheValue<T>(SourceType, metadata, "Id", (long)Id);
+                    }
+                    else
+                    {
+                        metadata = Storage.GetCacheValue<T>(SourceType, metadata, "Slug", (string)Id);
+                    }
+                    break;
+
+                case Storage.CacheStatus.Expired:
+                    try
+                    {
+                        if (idType == IdType.Long)
+                        {
+                            metadata = GetMetadataFromServer<T>(SourceType, (long)Id).Result;
+                        }
+                        else
+                        {
+                            metadata = GetMetadataFromServer<T>(SourceType, (string)Id).Result;
+                        }
+                        Storage.NewCacheValue<T>(SourceType, metadata, true);
+                    }
+                    catch (Exception e)
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Fetch Metadata", "Failed to fetch metadata from source: " + SourceType + " for id: " + Id + " of type: " + type + ". Error: " + e.Message);
+                        metadata = null;
+                    }
+                    break;
+
+                case Storage.CacheStatus.NotPresent:
+                    try
+                    {
+                        if (idType == IdType.Long)
+                        {
+                            metadata = GetMetadataFromServer<T>(SourceType, (long)Id).Result;
+                        }
+                        else
+                        {
+                            metadata = GetMetadataFromServer<T>(SourceType, (string)Id).Result;
+                        }
+                        Storage.NewCacheValue<T>(SourceType, metadata, false);
+                    }
+                    catch (Exception e)
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Fetch Metadata", "Failed to fetch metadata from source: " + SourceType + " for id: " + Id + " of type: " + type + ". Error: " + e.Message);
+                        metadata = null;
+                    }
+                    break;
+            }
+
+            return metadata;
+        }
+
+        private enum IdType
+        {
+            Long,
+            String
+        }
+
+        private static async Task<T> GetMetadataFromServer<T>(HasheousClient.Models.MetadataSources SourceType, long Id) where T : class
+        {
+            // get T type as string
+            string type = typeof(T).Name;
+
+            if (SourceType == HasheousClient.Models.MetadataSources.None)
+            {
+                // generate a dummy object
+                var returnObject = (T)Activator.CreateInstance(typeof(T));
+                returnObject.GetType().GetProperty("Id").SetValue(returnObject, Id);
+
+                // if returnObject has a property called "name", query the metadatamap view for the name
+                if (returnObject.GetType().GetProperty("Name") != null)
+                {
+                    Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                    string sql = "SELECT * FROM MetadataMap JOIN MetadataMapBridge ON MetadataMap.Id = MetadataMapBridge.ParentMapId WHERE MetadataSourceId = @id AND MetadataSourceType = 0;";
+                    DataTable dataTable = db.ExecuteCMD(sql, new Dictionary<string, object>
+                    {
+                        { "@id", Id }
+                    });
+                    if (dataTable.Rows.Count > 0)
+                    {
+                        returnObject.GetType().GetProperty("Name").SetValue(returnObject, dataTable.Rows[0]["SignatureGameName"].ToString());
+                    }
+                }
+
+                return returnObject;
+            }
+            else
+            {
+                // get metadata from the server
+                Communications comms = new Communications();
+                var results = await comms.APIComm<T>(SourceType, (Communications.MetadataEndpoint)Enum.Parse(typeof(Communications.MetadataEndpoint), type, true), Id);
+
+                // check for errors
+                if (results == null)
+                {
+                    throw new InvalidMetadataId(SourceType, Id);
+                }
+
+                return results.FirstOrDefault<T>();
+            }
+        }
+
+        private static async Task<T> GetMetadataFromServer<T>(HasheousClient.Models.MetadataSources SourceType, string Id) where T : class
+        {
+            // get T type as string
+            string type = typeof(T).Name;
+
+            if (SourceType == HasheousClient.Models.MetadataSources.None)
+            {
+                // generate a dummy object
+                return (T)Activator.CreateInstance(typeof(T));
+            }
+            else
+            {
+                // get metadata from the server
+                Communications comms = new Communications();
+                var results = await comms.APIComm<T>(SourceType, (Communications.MetadataEndpoint)Enum.Parse(typeof(Communications.MetadataEndpoint), type, true), Id);
+
+                // check for errors
+                if (results == null)
+                {
+                    throw new InvalidMetadataId(SourceType, Id);
+                }
+
+                return results.FirstOrDefault<T>();
+            }
+        }
+
+        #endregion
+    }
+}

gaseous-server/Classes/Metadata/MultiplayerModes.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class MultiplayerModes
     {
-        const string fieldList = "fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;";
+        public const string fieldList = "fields campaigncoop,checksum,dropin,game,lancoop,offlinecoop,offlinecoopmax,offlinemax,onlinecoop,onlinecoopmax,onlinemax,platform,splitscreen,splitscreenonline;";
 
         public MultiplayerModes()
         {
         }
 
-        public static MultiplayerMode? GetGame_MultiplayerModes(long? Id)
+        public static MultiplayerMode? GetGame_MultiplayerModes(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<MultiplayerMode> RetVal = _GetGame_MultiplayerModes(SearchUsing.id, Id);
-                return RetVal.Result;
+                MultiplayerMode? RetVal = Metadata.GetMetadata<MultiplayerMode>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static MultiplayerMode GetGame_MultiplayerModes(string Slug)
-        {
-            Task<MultiplayerMode> RetVal = _GetGame_MultiplayerModes(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<MultiplayerMode> _GetGame_MultiplayerModes(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("MultiplayerMode", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("MultiplayerMode", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            MultiplayerMode returnValue = new MultiplayerMode();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<MultiplayerMode>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<MultiplayerMode>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<MultiplayerMode> GetObjectFromServer(string WhereClause)
-        {
-            // get Game_MultiplayerModes metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<MultiplayerMode>(IGDBClient.Endpoints.MultiplayerModes, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/PlatformLogos.cs

@@ -1,19 +1,19 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
+using static gaseous_server.Models.PlatformMapping;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class PlatformLogos
     {
-        const string fieldList = "fields alpha_channel,animated,checksum,height,image_id,url,width;";
+        public const string fieldList = "fields alpha_channel,animated,checksum,height,image_id,url,width;";
 
         public PlatformLogos()
         {
         }
 
-        public static PlatformLogo? GetPlatformLogo(long? Id, string ImagePath)
+        public static PlatformLogo? GetPlatformLogo(long? Id, HasheousClient.Models.MetadataSources SourceType = HasheousClient.Models.MetadataSources.IGDB)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,107 +21,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<PlatformLogo> RetVal = _GetPlatformLogo(SearchUsing.id, Id, ImagePath);
-                return RetVal.Result;
+                PlatformLogo? RetVal = Metadata.GetMetadata<PlatformLogo>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static PlatformLogo GetPlatformLogo(string Slug, string ImagePath)
-        {
-            Task<PlatformLogo> RetVal = _GetPlatformLogo(SearchUsing.slug, Slug, ImagePath);
-            return RetVal.Result;
-        }
-
-        private static async Task<PlatformLogo> _GetPlatformLogo(SearchUsing searchUsing, object searchValue, string ImagePath)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("PlatformLogo", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("PlatformLogo", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            PlatformLogo returnValue = new PlatformLogo();
-            bool forceImageDownload = false;
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                    if (returnValue != null)
-                    {
-                        Storage.NewCacheValue(returnValue);
-                        forceImageDownload = true;
-                    }
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<PlatformLogo>(returnValue, "id", (long)searchValue);
-                    }
-                    break;  
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<PlatformLogo>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            if (returnValue != null)
-            {
-                // check for presence of "original" quality file - download if absent or force download is true
-                string localFile = Path.Combine(ImagePath, Communications.IGDBAPI_ImageSize.original.ToString(), returnValue.ImageId + ".jpg");
-                if ((!File.Exists(localFile)) || forceImageDownload == true)
-                {
-                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Platform logo download forced.");
-
-                    Communications comms = new Communications();
-                    comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
-                }
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<PlatformLogo> GetObjectFromServer(string WhereClause, string ImagePath)
-        {
-            // get Artwork metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<PlatformLogo>(IGDBClient.Endpoints.PlatformLogos, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/PlatformVersions.cs

@@ -1,19 +1,18 @@
 using System;
 using System.Data;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class PlatformVersions
     {
-        const string fieldList = "fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;";
+        public const string fieldList = "fields checksum,companies,connectivity,cpu,graphics,main_manufacturer,media,memory,name,online,os,output,platform_logo,platform_version_release_dates,resolutions,slug,sound,storage,summary,url;";
 
         public PlatformVersions()
         {
         }
 
-        public static PlatformVersion? GetPlatformVersion(long Id, Platform ParentPlatform)
+        public static PlatformVersion? GetPlatformVersion(HasheousClient.Models.MetadataSources SourceType, long Id)
         {
             if (Id == 0)
             {
@@ -21,110 +20,8 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.id, Id, ParentPlatform);
-                return RetVal.Result;
-            }
-        }
-
-        public static PlatformVersion GetPlatformVersion(string Slug, Platform ParentPlatform)
-        {
-            Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.slug, Slug, ParentPlatform);
-            return RetVal.Result;
-        }
-
-        private static async Task<PlatformVersion> _GetPlatformVersion(SearchUsing searchUsing, object searchValue, Platform ParentPlatform)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("PlatformVersion", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("PlatformVersion", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            PlatformVersion returnValue = new PlatformVersion();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    if (returnValue != null)
-                    {
-                        Storage.NewCacheValue(returnValue);
-                        UpdateSubClasses(ParentPlatform, returnValue);
-                    }
-                    return returnValue;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(ParentPlatform, returnValue);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<PlatformVersion>(returnValue, "id", (long)searchValue);
-                    }
-                    return returnValue;
-                case Storage.CacheStatus.Current:
-                    return Storage.GetCacheValue<PlatformVersion>(returnValue, "id", (long)searchValue);
-                default:
-                    throw new Exception("How did you get here?");
-            }
-        }
-
-        private static void UpdateSubClasses(Platform ParentPlatform, PlatformVersion platformVersion)
-        {
-            if (platformVersion.PlatformLogo != null)
-            {
-                try
-                {
-                    PlatformLogo platformLogo = PlatformLogos.GetPlatformLogo(platformVersion.PlatformLogo.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(ParentPlatform), "Versions", platformVersion.Slug));
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Warning, "Platform Update", "Unable to fetch platform logo", ex);
-                }
-            }
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<PlatformVersion?> GetObjectFromServer(string WhereClause)
-        {
-            // get PlatformVersion metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<PlatformVersion>(IGDBClient.Endpoints.PlatformVersions, fieldList, WhereClause);
-            if (results.Length > 0)
-            {
-                var result = results.First();
-
-                return result;
-            }
-            else
-            {
-                return null;
+                PlatformVersion? RetVal = Metadata.GetMetadata<PlatformVersion>(SourceType, Id, false);
+                return RetVal;
             }
         }
     }

gaseous-server/Classes/Metadata/Platforms.cs

@@ -1,146 +1,71 @@
 using System;
 using System.Data;
 using System.Net;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Platforms
     {
-        const string fieldList = "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;";
+        public const string fieldList = "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites;";
 
         public Platforms()
         {
 
         }
 
-        public static Platform? GetPlatform(long Id, bool forceRefresh = false)
+        public static Platform? GetPlatform(long Id, HasheousClient.Models.MetadataSources? SourceType = null)
         {
-            if (Id == 0)
+            HasheousClient.Models.MetadataSources Source = SourceType ?? Communications.MetadataSource;
+
+            if ((Id == 0) || (Id == null))
             {
                 Platform returnValue = new Platform();
-                if (Storage.GetCacheStatus("Platform", 0) == Storage.CacheStatus.NotPresent)
+                if (Storage.GetCacheStatus(Source, "Platform", 0) == Storage.CacheStatus.NotPresent)
                 {
                     returnValue = new Platform
                     {
                         Id = 0,
                         Name = "Unknown Platform",
-                        Slug = "Unknown"
+                        Slug = "unknown"
                     };
-                    Storage.NewCacheValue(returnValue);
+                    Storage.NewCacheValue(Source, returnValue);
 
                     return returnValue;
                 }
                 else
                 {
-                    return Storage.GetCacheValue<Platform>(returnValue, "id", 0);
+                    return Storage.GetCacheValue<Platform>(Source, returnValue, "id", 0);
                 }
             }
             else
             {
-                try
+                Platform? RetVal = new Platform();
+                RetVal = (Platform?)Storage.GetCacheValue<Platform>(HasheousClient.Models.MetadataSources.None, RetVal, "Id", (long)Id);
+                if (Source != HasheousClient.Models.MetadataSources.None)
                 {
-                    Task<Platform> RetVal = _GetPlatform(SearchUsing.id, Id, forceRefresh);
-                    return RetVal.Result;
-                }
-                catch(Exception ex)
+                    if (RetVal == null)
                     {
-                    Logging.Log(Logging.LogType.Warning, "Metadata", "An error occurred fetching Platform Id " + Id, ex);
-                    return null;
+                        RetVal = Metadata.GetMetadata<Platform>(Source, (long)Id, false);
                     }
                 }
+                return RetVal;
+            }
         }
 
-		public static Platform GetPlatform(string Slug, bool forceRefresh = false)
+        public static Platform GetPlatform(string Slug)
         {
-			Task<Platform> RetVal = _GetPlatform(SearchUsing.slug, Slug, forceRefresh);
-			return RetVal.Result;
+            // get platform id from slug - query Platform table
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string query = "SELECT Id FROM Platform WHERE slug = @slug AND SourceId = @sourceid;";
+            DataTable result = db.ExecuteCMD(query, new Dictionary<string, object> { { "@slug", Slug }, { "@sourceid", HasheousClient.Models.MetadataSources.IGDB } });
+            if (result.Rows.Count == 0)
+            {
+                throw new Metadata.InvalidMetadataId(Slug);
             }
 
-		private static async Task<Platform> _GetPlatform(SearchUsing searchUsing, object searchValue, bool forceRefresh)
-		{
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Platform", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Platform", (string)searchValue);
-            }
-
-            if (forceRefresh == true)
-            {
-                if (cacheStatus == Storage.CacheStatus.Current) { cacheStatus = Storage.CacheStatus.Expired; }
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Platform returnValue = new Platform();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    UpdateSubClasses(returnValue);
-                    AddPlatformMapping(returnValue);
-                    return returnValue;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(returnValue);
-                        AddPlatformMapping(returnValue);
-                        return returnValue;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        return Storage.GetCacheValue<Platform>(returnValue, "id", (long)searchValue);
-                    }
-                case Storage.CacheStatus.Current:
-                    return Storage.GetCacheValue<Platform>(returnValue, "id", (long)searchValue);
-                default:
-                    throw new Exception("How did you get here?");
-            }
-        }
-
-        private static void UpdateSubClasses(Platform platform)
-        {
-            if (platform.Versions != null)
-            {
-                foreach (long PlatformVersionId in platform.Versions.Ids)
-                {
-                    PlatformVersion platformVersion = PlatformVersions.GetPlatformVersion(PlatformVersionId, platform);
-                }
-            }
-
-            if (platform.PlatformLogo != null)
-            {
-                try
-                {
-                    PlatformLogo platformLogo = PlatformLogos.GetPlatformLogo(platform.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platform));
-                }
-                catch (Exception ex)
-                {
-                    Logging.Log(Logging.LogType.Warning, "Platform Update", "Unable to fetch platform logo", ex);
-                }
-            }
+            long Id = (long)result.Rows[0]["Id"];
+            return GetPlatform(Id);
         }
 
         private static void AddPlatformMapping(Platform platform)
@@ -158,7 +83,8 @@ namespace gaseous_server.Classes.Metadata
             {
                 Logging.Log(Logging.LogType.Information, "Platform Map", "Importing " + platform.Name + " from predefined data.");
                 // doesn't exist - add it
-                item = new Models.PlatformMapping.PlatformMapItem{
+                item = new Models.PlatformMapping.PlatformMapItem
+                {
                     IGDBId = (long)platform.Id,
                     IGDBName = platform.Name,
                     IGDBSlug = platform.Slug,
@@ -167,36 +93,6 @@ namespace gaseous_server.Classes.Metadata
                 Models.PlatformMapping.WritePlatformMap(item, false, true);
             }
         }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Platform> GetObjectFromServer(string WhereClause)
-        {
-            // get platform metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Platform>(IGDBClient.Endpoints.Platforms, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
-
-        public static void AssignAllPlatformsToGameIdZero()
-        {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT * FROM Platform;";
-            DataTable platformsTable = db.ExecuteCMD(sql);
-            foreach (DataRow platformRow in platformsTable.Rows)
-            {
-                sql = "DELETE FROM Relation_Game_Platforms WHERE GameId = 0 AND PlatformsId = @Id; INSERT INTO Relation_Game_Platforms (GameId, PlatformsId) VALUES (0, @Id);";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("Id", (long)platformRow["Id"]);
-                db.ExecuteCMD(sql, dbDict);
-            }
-        }
     }
 }
 

gaseous-server/Classes/Metadata/PlayerPerspectives.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class PlayerPerspectives
     {
-        const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
+        public const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
 
         public PlayerPerspectives()
         {
         }
 
-        public static PlayerPerspective? GetGame_PlayerPerspectives(long? Id)
+        public static PlayerPerspective? GetGame_PlayerPerspectives(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,90 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<PlayerPerspective> RetVal = _GetGame_PlayerPerspectives(SearchUsing.id, Id);
-                return RetVal.Result;
+                PlayerPerspective? RetVal = Metadata.GetMetadata<PlayerPerspective>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static PlayerPerspective GetGame_PlayerPerspectives(string Slug)
-        {
-            Task<PlayerPerspective> RetVal = _GetGame_PlayerPerspectives(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<PlayerPerspective> _GetGame_PlayerPerspectives(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("PlayerPerspective", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("PlayerPerspective", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            PlayerPerspective returnValue = new PlayerPerspective();
-            bool forceImageDownload = false;
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    forceImageDownload = true;
-                    break;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<PlayerPerspective>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<PlayerPerspective>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<PlayerPerspective> GetObjectFromServer(string WhereClause)
-        {
-            // get Game_PlayerPerspectives metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<PlayerPerspective>(IGDBClient.Endpoints.PlayerPerspectives, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/ReleaseDates.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class ReleaseDates
     {
-        const string fieldList = "fields category,checksum,created_at,date,game,human,m,platform,region,status,updated_at,y;";
+        public const string fieldList = "fields category,checksum,created_at,date,game,human,m,platform,region,status,updated_at,y;";
 
         public ReleaseDates()
         {
         }
 
-        public static ReleaseDate? GetReleaseDates(long? Id)
+        public static ReleaseDate? GetReleaseDates(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,88 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<ReleaseDate> RetVal = _GetReleaseDates(SearchUsing.id, Id);
-                return RetVal.Result;
+                ReleaseDate? RetVal = Metadata.GetMetadata<ReleaseDate>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static ReleaseDate GetReleaseDates(string Slug)
-        {
-            Task<ReleaseDate> RetVal = _GetReleaseDates(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<ReleaseDate> _GetReleaseDates(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("ReleaseDate", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("ReleaseDate", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            ReleaseDate returnValue = new ReleaseDate();
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<ReleaseDate>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<ReleaseDate>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<ReleaseDate> GetObjectFromServer(string WhereClause)
-        {
-            // get ReleaseDates metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<ReleaseDate>(IGDBClient.Endpoints.ReleaseDates, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Screenshots.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Screenshots
     {
-        const string fieldList = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;";
+        public const string fieldList = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;";
 
         public Screenshots()
         {
         }
 
-        public static Screenshot? GetScreenshot(long? Id, string ImagePath, bool GetImages)
+        public static Screenshot? GetScreenshot(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,105 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Screenshot> RetVal = _GetScreenshot(SearchUsing.id, Id, ImagePath, GetImages);
-                return RetVal.Result;
+                Screenshot? RetVal = Metadata.GetMetadata<Screenshot>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static Screenshot GetScreenshot(string Slug, string ImagePath, bool GetImages)
-        {
-            Task<Screenshot> RetVal = _GetScreenshot(SearchUsing.slug, Slug, ImagePath, GetImages);
-            return RetVal.Result;
-        }
-
-        private static async Task<Screenshot> _GetScreenshot(SearchUsing searchUsing, object searchValue, string ImagePath, bool GetImages = true)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Screenshot", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Screenshot", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Screenshot returnValue = new Screenshot();
-            bool forceImageDownload = false;
-            ImagePath = Path.Combine(ImagePath, "Screenshots");
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                    Storage.NewCacheValue(returnValue);
-                    forceImageDownload = true;
-                    break;  
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
-                        Storage.NewCacheValue(returnValue, true);
-                        forceImageDownload = true;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        returnValue = Storage.GetCacheValue<Screenshot>(returnValue, "id", (long)searchValue);
-                    }
-                    break;
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Screenshot>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            // check for presence of "original" quality file - download if absent or force download is true
-            string localFile = Path.Combine(ImagePath, Communications.IGDBAPI_ImageSize.original.ToString(), returnValue.ImageId + ".jpg");
-            if (GetImages == true)
-            {
-                if ((!File.Exists(localFile)) || forceImageDownload == true)
-                {
-                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Screenshot download forced.");
-
-                    Communications comms = new Communications();
-                    comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
-                }
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Screenshot> GetObjectFromServer(string WhereClause, string ImagePath)
-        {
-            // get Screenshot metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Screenshot>(IGDBClient.Endpoints.Screenshots, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Storage.cs

@@ -9,23 +9,79 @@ namespace gaseous_server.Classes.Metadata
 {
     public class Storage
     {
+        /// <summary>
+        /// Cache status of a record
+        /// </summary>
         public enum CacheStatus
         {
+            /// <summary>
+            /// The record is not present in the database
+            /// </summary>
             NotPresent,
+
+            /// <summary>
+            /// The record is present in the database and is current
+            /// </summary>
             Current,
+
+            /// <summary>
+            /// The record is present in the database but is expired
+            /// </summary>
             Expired
         }
 
-		public static CacheStatus GetCacheStatus(string Endpoint, string Slug)
+        /// <summary>
+        /// Get the cache status of a record in the database
+        /// </summary>
+        /// <param name="SourceType">
+        /// The source of the metadata (IGDB, RAWG, etc.)
+        /// </param>
+        /// <param name="Endpoint">
+        /// The endpoint of the metadata (games, companies, etc.)
+        /// </param>
+        /// <param name="Slug">
+        /// The slug of the metadata record
+        /// </param>
+        /// <returns>
+        /// The cache status of the record
+        /// </returns>
+        public static CacheStatus GetCacheStatus(HasheousClient.Models.MetadataSources SourceType, string Endpoint, string Slug)
         {
-            return _GetCacheStatus(Endpoint, "slug", Slug);
+            return _GetCacheStatus(SourceType, Endpoint, "slug", Slug);
         }
 
-        public static CacheStatus GetCacheStatus(string Endpoint, long Id)
+        /// <summary>
+        /// Get the cache status of a record in the database
+        /// </summary>
+        /// <param name="SourceType">
+        /// The source of the metadata (IGDB, RAWG, etc.)
+        /// </param>
+        /// <param name="Endpoint">
+        /// The endpoint of the metadata (games, companies, etc.)
+        /// </param>
+        /// <param name="Id">
+        /// The ID of the metadata record
+        /// </param>
+        /// <returns>
+        /// The cache status of the record
+        /// </returns>
+        public static CacheStatus GetCacheStatus(HasheousClient.Models.MetadataSources SourceType, string Endpoint, long Id)
         {
-            return _GetCacheStatus(Endpoint, "id", Id);
+            return _GetCacheStatus(SourceType, Endpoint, "id", Id);
         }
 
+        /// <summary>
+        /// Get the cache status of a record in the database
+        /// </summary>
+        /// <param name="Row">
+        /// The DataRow object to check
+        /// </param>
+        /// <returns>
+        /// The cache status of the record
+        /// </returns>
+        /// <exception cref="Exception">
+        /// Thrown when the DataRow object does not contain a "lastUpdated" column
+        /// </exception>
         public static CacheStatus GetCacheStatus(DataRow Row)
         {
             if (Row.Table.Columns.Contains("lastUpdated"))
@@ -46,13 +102,14 @@ namespace gaseous_server.Classes.Metadata
             }
         }
 
-        private static CacheStatus _GetCacheStatus(string Endpoint, string SearchField, object SearchValue)
+        private static CacheStatus _GetCacheStatus(HasheousClient.Models.MetadataSources SourceType, string Endpoint, string SearchField, object SearchValue)
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
-			string sql = "SELECT lastUpdated FROM " + Endpoint + " WHERE " + SearchField + " = @" + SearchField;
+            string sql = "SELECT lastUpdated FROM " + Endpoint + " WHERE SourceId = @SourceType AND " + SearchField + " = @" + SearchField;
 
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("SourceType", SourceType);
             dbDict.Add("Endpoint", Endpoint);
             dbDict.Add(SearchField, SearchValue);
 
@@ -76,16 +133,41 @@ namespace gaseous_server.Classes.Metadata
             }
         }
 
-		public static void NewCacheValue(object ObjectToCache, bool UpdateRecord = false)
+        /// <summary>
+        /// Add a new record to the cache
+        /// </summary>
+        /// <param name="SourceType">
+        /// The source of the metadata (IGDB, RAWG, etc.)
+        /// </param>
+        /// <param name="ObjectToCache">
+        /// The object to cache
+        /// </param>
+        /// <param name="UpdateRecord">
+        /// Whether to update the record if it already exists
+        /// </param>
+        public static void NewCacheValue<T>(HasheousClient.Models.MetadataSources SourceType, T ObjectToCache, bool UpdateRecord = false)
         {
             // get the object type name
             string ObjectTypeName = ObjectToCache.GetType().Name;
 
             // build dictionary
-			string objectJson = Newtonsoft.Json.JsonConvert.SerializeObject(ObjectToCache);
-			Dictionary<string, object?> objectDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object?>>(objectJson);
-            objectDict.Add("dateAdded", DateTime.UtcNow);
-            objectDict.Add("lastUpdated", DateTime.UtcNow);
+            Dictionary<string, object?> objectDict = new Dictionary<string, object?>
+            {
+                { "SourceId", SourceType },
+                { "dateAdded", DateTime.UtcNow },
+                { "lastUpdated", DateTime.UtcNow }
+            };
+            foreach (PropertyInfo property in ObjectToCache.GetType().GetProperties())
+            {
+                if (property.GetCustomAttribute<Models.NoDatabaseAttribute>() == null)
+                {
+                    object? propertyValue = property.GetValue(ObjectToCache);
+                    if (propertyValue != null)
+                    {
+                        objectDict.Add(property.Name, propertyValue);
+                    }
+                }
+            }
 
             // generate sql
             string fieldList = "";
@@ -100,7 +182,7 @@ namespace gaseous_server.Classes.Metadata
                 }
                 fieldList = fieldList + key.Key;
                 valueList = valueList + "@" + key.Key;
-				if ((key.Key != "id") && (key.Key != "dateAdded"))
+                if ((key.Key != "id") && (key.Key != "dateAdded") && (key.Key != "SourceId"))
                 {
                     if (updateFieldValueList.Length > 0)
                     {
@@ -135,7 +217,13 @@ namespace gaseous_server.Classes.Metadata
                                     newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(newDict["Ids"]);
                                     objectDict[key.Key] = newObjectValue;
 
-                                    StoreRelations(ObjectTypeName, key.Key, (long)objectDict["Id"], newObjectValue);
+                                    StoreRelations(SourceType, ObjectTypeName, key.Key, (long)objectDict["Id"], newObjectValue);
+                                    break;
+                                case "list":
+                                    newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(objectValue);
+                                    objectDict[key.Key] = newObjectValue;
+
+                                    StoreRelations(SourceType, ObjectTypeName, key.Key, (long)objectDict["Id"], newObjectValue);
 
                                     break;
                                 case "int32[]":
@@ -151,11 +239,11 @@ namespace gaseous_server.Classes.Metadata
             string sql = "";
             if (UpdateRecord == false)
             {
-				sql = "INSERT INTO " + ObjectTypeName + " (" + fieldList + ") VALUES (" + valueList + ")";
+                sql = "INSERT INTO " + ObjectTypeName + " (" + fieldList + ") VALUES (" + valueList + ");";
             }
             else
             {
-				sql = "UPDATE " + ObjectTypeName + " SET " + updateFieldValueList + " WHERE Id = @Id";
+                sql = "UPDATE " + ObjectTypeName + " SET " + updateFieldValueList + " WHERE Id = @Id AND SourceId = @SourceId;";
             }
 
             // execute sql
@@ -163,19 +251,44 @@ namespace gaseous_server.Classes.Metadata
             db.ExecuteCMD(sql, objectDict);
         }
 
-		public static T GetCacheValue<T>(T EndpointType, string SearchField, object SearchValue)
+        /// <summary>
+        /// Get a record from the cache
+        /// </summary>
+        /// <typeparam name="T">
+        /// The type of the object to return
+        /// </typeparam>
+        /// <param name="SourceType">
+        /// The source of the metadata (IGDB, RAWG, etc.)
+        /// </param>
+        /// <param name="EndpointType">
+        /// The type of the endpoint (games, companies, etc.)
+        /// </param>
+        /// <param name="SearchField">
+        /// The field to search for the record by
+        /// </param>
+        /// <param name="SearchValue">
+        /// The value to search for
+        /// </param>
+        /// <returns>
+        /// The object from the cache
+        /// </returns>
+        /// <exception cref="Exception">
+        /// Thrown when no record is found that matches the search criteria
+        /// </exception>
+        public static T GetCacheValue<T>(HasheousClient.Models.MetadataSources SourceType, T? EndpointType, string SearchField, object SearchValue)
         {
             string Endpoint = EndpointType.GetType().Name;
 
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
-            string sql = "SELECT * FROM " + Endpoint + " WHERE " + SearchField + " = @" + SearchField;
+            string sql = "SELECT * FROM " + Endpoint + " WHERE SourceId = @SourceType AND " + SearchField + " = @" + SearchField;
 
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("SourceType", SourceType);
             dbDict.Add("Endpoint", Endpoint);
             dbDict.Add(SearchField, SearchValue);
 
-            DataTable dt = db.ExecuteCMD(sql, dbDict);
+            DataTable dt = db.ExecuteCMD(sql, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromHours(8).Ticks));
             if (dt.Rows.Count == 0)
             {
                 // no data stored for this item
@@ -192,201 +305,65 @@ namespace gaseous_server.Classes.Metadata
 
         public static T BuildCacheObject<T>(T EndpointType, DataRow dataRow)
         {
+            // copy the DataRow to EndpointType
             foreach (PropertyInfo property in EndpointType.GetType().GetProperties())
             {
-                if (dataRow.Table.Columns.Contains(property.Name))
+                if (property.GetCustomAttribute<Models.NoDatabaseAttribute>() == null)
                 {
-                    if (dataRow[property.Name] != DBNull.Value)
+                    // get the value from the DataRow with the same name as the property
+                    if (dataRow.Table.Columns.Contains(property.Name) == true)
                     {
-                        string objectTypeName = property.PropertyType.Name.ToLower().Split("`")[0];
-                        string subObjectTypeName = "";
-                        object? objectToStore = null;
-                        if (objectTypeName == "nullable")
+                        object? value = dataRow[property.Name];
+
+                        if (value != null && value != DBNull.Value)
                         {
-                            objectTypeName = property.PropertyType.UnderlyingSystemType.ToString().Split("`1")[1].Replace("[System.", "").Replace("]", "").ToLower();
+                            // check the property type - if it's a list or array, deserialize it. Otherwise, just set the value
+                            Type objectType = EndpointType.GetType();
+                            if (objectType != null)
+                            {
+                                // fullname = System.Nullable`1[[System.DateTimeOffset,
+                                string propertyTypeName = property.PropertyType.FullName.Split(",")[0];
+                                bool isNullable = false;
+                                if (propertyTypeName.StartsWith("System.Nullable"))
+                                {
+                                    isNullable = true;
+                                    propertyTypeName = propertyTypeName.Split("[[")[1];
                                 }
-                        try
-                        {
-                            switch (objectTypeName)
-                            {
-                                //case "boolean":
-                                //    Boolean storedBool = Convert.ToBoolean((int)dataRow[property.Name]);
-                                //    property.SetValue(EndpointType, storedBool);
-                                //    break;
-                                case "datetimeoffset":
-                                    DateTimeOffset? storedDate = (DateTime?)dataRow[property.Name];
-                                    property.SetValue(EndpointType, storedDate);
-                                    break;
-                                //case "nullable":
-                                //	Console.WriteLine("Nullable: " + property.PropertyType.UnderlyingSystemType);
-                                //	break;
-                                case "identityorvalue":
-                                    subObjectTypeName = property.PropertyType.UnderlyingSystemType.ToString().Split("`1")[1].Replace("[IGDB.Models.", "").Replace("]", "").ToLower();
+                                propertyTypeName = propertyTypeName.Split("`")[0];
 
-                                    switch (subObjectTypeName)
+                                switch (propertyTypeName.ToLower())
                                 {
-                                        case "collection":
-                                            objectToStore = new IdentityOrValue<Collection>(id: (long)dataRow[property.Name]);
+                                    case "system.collections.generic.list":
+                                        var listArray = Newtonsoft.Json.JsonConvert.DeserializeObject<List<long>>(value.ToString());
+                                        property.SetValue(EndpointType, listArray);
                                         break;
-                                        case "company":
-                                            objectToStore = new IdentityOrValue<Company>(id: (long)dataRow[property.Name]);
-                                            break;
-                                        case "cover":
-                                            objectToStore = new IdentityOrValue<Cover>(id: (long)dataRow[property.Name]);
-                                            break;
-                                        case "franchise":
-                                            objectToStore = new IdentityOrValue<Franchise>(id: (long)dataRow[property.Name]);
-                                            break;
-                                        case "game":
-                                            objectToStore = new IdentityOrValue<Game>(id: (long)dataRow[property.Name]);
-                                            break;
-                                        case "platformfamily":
-                                            objectToStore = new IdentityOrValue<PlatformFamily>(id: (long)dataRow[property.Name]);
-                                            break;
-                                        case "platformlogo":
-                                            objectToStore = new IdentityOrValue<PlatformLogo>(id: (long)dataRow[property.Name]);
-                                            break;
-                                        case "platformversioncompany":
-                                            objectToStore = new IdentityOrValue<PlatformVersionCompany>(id: (long)dataRow[property.Name]);
-                                            break;
-                                    }
 
-                                    if (objectToStore != null)
-                                    {
-                                        property.SetValue(EndpointType, objectToStore);
-                                    }
+                                    case "system.int32[]":
+                                        var int32array = Newtonsoft.Json.JsonConvert.DeserializeObject<int[]>(value.ToString());
+                                        property.SetValue(EndpointType, int32array);
+                                        break;
 
+                                    case "system.datetimeoffset":
+                                        property.SetValue(EndpointType, (DateTimeOffset)(DateTime?)value);
                                         break;
-                                case "identitiesorvalues":
-                                    subObjectTypeName = property.PropertyType.UnderlyingSystemType.ToString().Split("`1")[1].Replace("[IGDB.Models.", "").Replace("]", "").ToLower();
 
-                                    long[] fromJsonObject = Newtonsoft.Json.JsonConvert.DeserializeObject<long[]>((string)dataRow[property.Name]);
-
-                                    switch (subObjectTypeName)
-                                    {
-                                        case "agerating":
-                                            objectToStore = new IdentitiesOrValues<AgeRating>(ids: fromJsonObject);
-                                            break;
-                                        case "alternativename":
-                                            objectToStore = new IdentitiesOrValues<AlternativeName>(ids: fromJsonObject);
-                                            break;
-                                        case "artwork":
-                                            objectToStore = new IdentitiesOrValues<Artwork>(ids: fromJsonObject);
-                                            break;
-                                        case "ageratingcontentdescription":
-                                            objectToStore = new IdentitiesOrValues<AgeRatingContentDescription>(ids: fromJsonObject);
-                                            break;
-                                        case "game":
-                                            objectToStore = new IdentitiesOrValues<Game>(ids: fromJsonObject);
-                                            break;
-                                        case "externalgame":
-                                            objectToStore = new IdentitiesOrValues<ExternalGame>(ids: fromJsonObject);
-                                            break;
-                                        case "franchise":
-                                            objectToStore = new IdentitiesOrValues<Franchise>(ids: fromJsonObject);
-                                            break;
-                                        case "gameengine":
-                                            objectToStore = new IdentitiesOrValues<GameEngine>(ids: fromJsonObject);
-                                            break;
-                                        case "gamemode":
-                                            objectToStore = new IdentitiesOrValues<GameMode>(ids: fromJsonObject);
-                                            break;
-                                        case "gamevideo":
-                                            objectToStore = new IdentitiesOrValues<GameVideo>(ids: fromJsonObject);
-                                            break;
-                                        case "genre":
-                                            objectToStore = new IdentitiesOrValues<Genre>(ids: fromJsonObject);
-                                            break;
-                                        case "involvedcompany":
-                                            objectToStore = new IdentitiesOrValues<InvolvedCompany>(ids: fromJsonObject);
-                                            break;
-                                        case "multiplayermode":
-                                            objectToStore = new IdentitiesOrValues<MultiplayerMode>(ids: fromJsonObject);
-                                            break;
-                                        case "platform":
-                                            objectToStore = new IdentitiesOrValues<Platform>(ids: fromJsonObject);
-                                            break;
-                                        case "platformversion":
-                                            objectToStore = new IdentitiesOrValues<PlatformVersion>(ids: fromJsonObject);
-                                            break;
-                                        case "platformwebsite":
-                                            objectToStore = new IdentitiesOrValues<PlatformWebsite>(ids: fromJsonObject);
-                                            break;
-                                        case "platformversioncompany":
-                                            objectToStore = new IdentitiesOrValues<PlatformVersionCompany>(ids: fromJsonObject);
-                                            break;
-                                        case "platformversionreleasedate":
-                                            objectToStore = new IdentitiesOrValues<PlatformVersionReleaseDate>(ids: fromJsonObject);
-                                            break;
-                                        case "playerperspective":
-                                            objectToStore = new IdentitiesOrValues<PlayerPerspective>(ids: fromJsonObject);
-                                            break;
-                                        case "releasedate":
-                                            objectToStore = new IdentitiesOrValues<ReleaseDate>(ids: fromJsonObject);
-                                            break;
-                                        case "screenshot":
-                                            objectToStore = new IdentitiesOrValues<Screenshot>(ids: fromJsonObject);
-                                            break;
-                                        case "theme":
-                                            objectToStore = new IdentitiesOrValues<Theme>(ids: fromJsonObject);
-                                            break;
-                                        case "website":
-                                            objectToStore = new IdentitiesOrValues<Website>(ids: fromJsonObject);
-                                            break;
-                                    }
-
-                                    if (objectToStore != null)
-                                    {
-                                        property.SetValue(EndpointType, objectToStore);
-                                    }
-
-                                    break;
-                                case "int32[]":
-                                    Int32[] fromJsonObject_int32Array = Newtonsoft.Json.JsonConvert.DeserializeObject<Int32[]>((string)dataRow[property.Name]);
-                                    if (fromJsonObject_int32Array != null)
-                                    {
-                                        property.SetValue(EndpointType, fromJsonObject_int32Array);
-                                    }
-                                    break;
-                                case "[igdb.models.category":
-                                    property.SetValue(EndpointType, (Category)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.gamestatus":
-                                    property.SetValue(EndpointType, (GameStatus)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.ageratingcategory":
-                                    property.SetValue(EndpointType, (AgeRatingCategory)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.ageratingcontentdescriptioncategory":
-                                    property.SetValue(EndpointType, (AgeRatingContentDescriptionCategory)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.ageratingtitle":
-                                    property.SetValue(EndpointType, (AgeRatingTitle)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.externalcategory":
-                                    property.SetValue(EndpointType, (ExternalCategory)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.startdatecategory":
-                                    property.SetValue(EndpointType, (StartDateCategory)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.releasedateregion":
-                                    property.SetValue(EndpointType, (ReleaseDateRegion)dataRow[property.Name]);
-                                    break;
-                                case "[igdb.models.releasedatecategory":
-                                    property.SetValue(EndpointType, (ReleaseDateCategory)dataRow[property.Name]);
-                                    break;
-                                case "[gaseous_server.classes.metadata.agegroups+agerestrictiongroupings":
-                                    property.SetValue(EndpointType, (AgeGroups.AgeRestrictionGroupings)dataRow[property.Name]);
-                                    break;
                                     default:
-                                    property.SetValue(EndpointType, dataRow[property.Name]);
+                                        // check if property is an enum
+                                        if (property.PropertyType.IsEnum)
+                                        {
+                                            property.SetValue(EndpointType, Enum.Parse(property.PropertyType, value.ToString()));
+                                        }
+                                        else if (Common.IsNullableEnum(property.PropertyType))
+                                        {
+                                            property.SetValue(EndpointType, Enum.Parse(Nullable.GetUnderlyingType(property.PropertyType), value.ToString()));
+                                        }
+                                        else
+                                        {
+                                            property.SetValue(EndpointType, value);
+                                        }
                                         break;
                                 }
                             }
-                        catch (Exception ex)
-                        {
-                            Console.WriteLine("Error occurred in column " + property.Name);
-                            Console.WriteLine(ex.ToString());
                         }
                     }
                 }
@@ -395,7 +372,7 @@ namespace gaseous_server.Classes.Metadata
             return EndpointType;
         }
 
-        private static void StoreRelations(string PrimaryTable, string SecondaryTable, long ObjectId, string Relations)
+        private static void StoreRelations(HasheousClient.Models.MetadataSources SourceType, string PrimaryTable, string SecondaryTable, long ObjectId, string Relations)
         {
             string TableName = "Relation_" + PrimaryTable + "_" + SecondaryTable;
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
@@ -404,7 +381,13 @@ namespace gaseous_server.Classes.Metadata
             if (data.Rows.Count == 0)
             {
                 // table doesn't exist, create it
-                sql = "CREATE TABLE `" + Config.DatabaseConfiguration.DatabaseName + "`.`" + TableName + "` (`" + PrimaryTable + "Id` BIGINT NOT NULL, `" + SecondaryTable + "Id` BIGINT NOT NULL, PRIMARY KEY (`" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`), INDEX `idx_PrimaryColumn` (`" + PrimaryTable + "Id` ASC) VISIBLE);";
+                sql = @"
+                    CREATE TABLE 
+                    `" + Config.DatabaseConfiguration.DatabaseName + "`.`" + TableName + @"` 
+                    (`" + PrimaryTable + @"SourceId` INT NOT NULL, 
+                    `" + PrimaryTable + @"Id` BIGINT NOT NULL, 
+                    `" + SecondaryTable + @"Id` BIGINT NOT NULL, 
+                    PRIMARY KEY (`" + PrimaryTable + "SourceId`, `" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`), INDEX `idx_PrimaryColumn` (`" + PrimaryTable + "Id` ASC) VISIBLE);";
                 db.ExecuteCMD(sql);
             }
             else
@@ -420,14 +403,47 @@ namespace gaseous_server.Classes.Metadata
             long[] RelationValues = Newtonsoft.Json.JsonConvert.DeserializeObject<long[]>(Relations);
             foreach (long RelationValue in RelationValues)
             {
-                sql = "INSERT INTO " + TableName + " (`" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`) VALUES (@objectid, @relationvalue);";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("objectid", ObjectId);
-                dbDict.Add("relationvalue", RelationValue);
+                sql = "INSERT INTO " + TableName + " (`" + PrimaryTable + "SourceId`, `" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`) VALUES (@sourceid, @objectid, @relationvalue);";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>
+                {
+                    { "sourceid", SourceType },
+                    { "objectid", ObjectId },
+                    { "relationvalue", RelationValue }
+                };
                 db.ExecuteCMD(sql, dbDict);
             }
         }
 
+        public static void CreateRelationsTables<T>()
+        {
+            string PrimaryTable = typeof(T).Name;
+            foreach (PropertyInfo property in typeof(T).GetProperties())
+            {
+                string SecondaryTable = property.Name;
+
+                if (property.PropertyType.Name == "IdentitiesOrValues`1")
+                {
+
+                    string TableName = "Relation_" + PrimaryTable + "_" + SecondaryTable;
+                    Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                    string sql = "SELECT * FROM information_schema.tables WHERE table_schema = '" + Config.DatabaseConfiguration.DatabaseName + "' AND table_name = '" + TableName + "';";
+                    DataTable data = db.ExecuteCMD(sql);
+                    if (data.Rows.Count == 0)
+                    {
+                        // table doesn't exist, create it
+                        sql = @"
+                            CREATE TABLE 
+                            `" + Config.DatabaseConfiguration.DatabaseName + "`.`" + TableName + @"` 
+                            (`" + PrimaryTable + @"SourceId` INT NOT NULL, 
+                            `" + PrimaryTable + @"Id` BIGINT NOT NULL, 
+                            `" + SecondaryTable + @"Id` BIGINT NOT NULL, 
+                            PRIMARY KEY (`" + PrimaryTable + "SourceId`, `" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`), INDEX `idx_PrimaryColumn` (`" + PrimaryTable + "Id` ASC) VISIBLE);";
+                        db.ExecuteCMD(sql);
+                    }
+                }
+            }
+        }
+
         private class MemoryCacheObject
         {
             public object Object { get; set; }

gaseous-server/Classes/Metadata/Themes.cs

@@ -1,19 +1,18 @@
 using System;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Themes
     {
-        const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
+        public const string fieldList = "fields checksum,created_at,name,slug,updated_at,url;";
 
         public Themes()
         {
         }
 
-        public static Theme? GetGame_Themes(long? Id)
+        public static Theme? GetGame_Themes(HasheousClient.Models.MetadataSources SourceType, long? Id)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -21,90 +20,10 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Theme> RetVal = _GetGame_Themes(SearchUsing.id, Id);
-                return RetVal.Result;
+                Theme? RetVal = Metadata.GetMetadata<Theme>(SourceType, (long)Id, false);
+                return RetVal;
             }
         }
-
-        public static Theme GetGame_Themes(string Slug)
-        {
-            Task<Theme> RetVal = _GetGame_Themes(SearchUsing.slug, Slug);
-            return RetVal.Result;
-        }
-
-        private static async Task<Theme> _GetGame_Themes(SearchUsing searchUsing, object searchValue)
-        {
-            // check database first
-            Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
-            if (searchUsing == SearchUsing.id)
-            {
-                cacheStatus = Storage.GetCacheStatus("Theme", (long)searchValue);
-            }
-            else
-            {
-                cacheStatus = Storage.GetCacheStatus("Theme", (string)searchValue);
-            }
-
-            // set up where clause
-            string WhereClause = "";
-            switch (searchUsing)
-            {
-                case SearchUsing.id:
-                    WhereClause = "where id = " + searchValue;
-                    break;
-                case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
-                    break;
-                default:
-                    throw new Exception("Invalid search type");
-            }
-
-            Theme returnValue = new Theme();
-            bool forceImageDownload = false;
-            switch (cacheStatus)
-            {
-                case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause);
-                    Storage.NewCacheValue(returnValue);
-                    forceImageDownload = true;
-                    break;
-                case Storage.CacheStatus.Expired:
-                    try
-                    {
-                        returnValue = await GetObjectFromServer(WhereClause);
-                        Storage.NewCacheValue(returnValue, true);
-                        return returnValue;
-                    }
-                    catch (Exception ex)
-                    {
-                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
-                        return Storage.GetCacheValue<Theme>(returnValue, "id", (long)searchValue);
-                    }
-                case Storage.CacheStatus.Current:
-                    returnValue = Storage.GetCacheValue<Theme>(returnValue, "id", (long)searchValue);
-                    break;
-                default:
-                    throw new Exception("How did you get here?");
-            }
-
-            return returnValue;
-        }
-
-        private enum SearchUsing
-        {
-            id,
-            slug
-        }
-
-        private static async Task<Theme> GetObjectFromServer(string WhereClause)
-        {
-            // get Game_Themes metadata
-            Communications comms = new Communications();
-            var results = await comms.APIComm<Theme>(IGDBClient.Endpoints.Themes, fieldList, WhereClause);
-            var result = results.First();
-
-            return result;
-        }
     }
 }
 

gaseous-server/Classes/MetadataManagement.cs

@@ -1,11 +1,354 @@
 using System;
 using System.Data;
+using gaseous_server.Classes.Metadata;
 using gaseous_server.Models;
+using HasheousClient.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes
 {
 	public class MetadataManagement : QueueItemStatus
 	{
+		private static bool Processing = false;
+
+		public enum MetadataMapSupportDataTypes
+		{
+			UserManualLink
+		}
+
+		/// <summary>
+		/// Creates a new metadata map, if one with the same platformId and name does not already exist.
+		/// </summary>
+		/// <param name="platformId">
+		/// The ID of the platform to which the metadata map belongs.
+		/// </param>
+		/// <param name="name">
+		/// The name of the metadata map.
+		/// </param>
+		/// <returns>
+		/// The ID of the new metadata map, or the ID of the existing metadata map if one already exists.
+		/// </returns>
+		public static MetadataMap? NewMetadataMap(long platformId, string name)
+		{
+			if (Processing == true)
+			{
+				// loop until processing = false
+				while (Processing == true)
+				{
+					System.Threading.Thread.Sleep(500);
+				}
+			}
+			Processing = true;
+
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@platformId", platformId },
+				{ "@name", name }
+			};
+			DataTable dt = new DataTable();
+
+			// check if the metadata map already exists
+			MetadataMap? existingMetadataMap = GetMetadataMap(platformId, name);
+			if (existingMetadataMap != null)
+			{
+				Processing = false;
+				return existingMetadataMap;
+			}
+
+			// create the metadata map
+			sql = "INSERT INTO MetadataMap (PlatformId, SignatureGameName) VALUES (@platformId, @name); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+			dt = db.ExecuteCMD(sql, dbDict);
+
+			long metadataMapId = (long)dt.Rows[0][0];
+
+			// create dummy game metadata item and capture id
+			sql = "INSERT INTO Game (SourceId, Name, dateAdded, lastUpdated) VALUES (@sourceid, @name, @dateadded, @lastupdated); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+			dbDict = new Dictionary<string, object>()
+			{
+				{ "@sourceid", HasheousClient.Models.MetadataSources.None },
+				{ "@name", name },
+				{ "@dateadded", DateTime.UtcNow },
+				{ "@lastupdated", DateTime.UtcNow }
+			};
+			dt = db.ExecuteCMD(sql, dbDict);
+
+			long gameId = (long)dt.Rows[0][0];
+
+			// add default metadata sources
+			AddMetadataMapItem(metadataMapId, HasheousClient.Models.MetadataSources.None, gameId, true);
+
+			// return the new metadata map
+			MetadataMap RetVal = GetMetadataMap(metadataMapId);
+			Processing = false;
+			return RetVal;
+		}
+
+		/// <summary>
+		/// Adds a metadata map item to the database.
+		/// </summary>
+		/// <param name="metadataMapId">
+		/// The ID of the metadata map to which the item belongs.
+		/// </param>
+		/// <param name="sourceType">
+		/// The type of the metadata source.
+		/// </param>
+		/// <param name="sourceId">
+		/// The ID of the metadata source.
+		/// </param>
+		/// <param name="preferred">
+		/// Whether the metadata source is preferred.
+		/// </param>
+		/// <remarks>
+		/// If the metadata source is preferred, all other metadata sources for the same metadata map will be set to not preferred.
+		/// </remarks>
+		public static void AddMetadataMapItem(long metadataMapId, HasheousClient.Models.MetadataSources sourceType, long sourceId, bool preferred)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@metadataMapId", metadataMapId },
+				{ "@sourceType", sourceType },
+				{ "@sourceId", sourceId },
+				{ "@preferred", preferred },
+				{ "@processedatimport", false }
+			};
+
+			if (preferred == true)
+			{
+				// set all other items to not preferred
+				sql = "UPDATE MetadataMapBridge SET Preferred = 0 WHERE ParentMapId = @metadataMapId;";
+				db.ExecuteCMD(sql, dbDict);
+			}
+
+			sql = "INSERT INTO MetadataMapBridge (ParentMapId, MetadataSourceType, MetadataSourceId, Preferred, ProcessedAtImport) VALUES (@metadataMapId, @sourceType, @sourceId, @preferred, @processedatimport);";
+			db.ExecuteCMD(sql, dbDict);
+		}
+
+		public static void UpdateMetadataMapItem(long metadataMapId, HasheousClient.Models.MetadataSources SourceType, long sourceId, bool? preferred = null)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@metadataMapId", metadataMapId },
+				{ "@sourceType", SourceType },
+				{ "@sourceId", sourceId },
+				{ "@preferred", preferred }
+			};
+
+			if (preferred == true)
+			{
+				// set all other items to not preferred
+				sql = "UPDATE MetadataMapBridge SET Preferred = 0 WHERE ParentMapId = @metadataMapId; UPDATE MetadataMapBridge SET MetadataSourceId = @sourceId, Preferred = @preferred WHERE ParentMapId = @metadataMapId AND MetadataSourceType = @sourceType;";
+				db.ExecuteCMD(sql, dbDict);
+			}
+			else
+			{
+				sql = "UPDATE MetadataMapBridge SET MetadataSourceId = @sourceId WHERE ParentMapId = @metadataMapId AND MetadataSourceType = @sourceType;";
+				db.ExecuteCMD(sql, dbDict);
+			}
+		}
+
+		/// <summary>
+		/// Gets a metadata map from the database.
+		/// </summary>
+		/// <param name="platformId">
+		/// The ID of the platform to which the metadata map belongs.
+		/// </param>
+		/// <param name="name">
+		/// The name of the metadata map.
+		/// </param>
+		/// <returns>
+		/// The metadata map, or null if it does not exist.
+		/// </returns>
+		/// <remarks>
+		/// This method will return the first metadata map found with the given platformId and name.
+		/// </remarks>
+		public static MetadataMap? GetMetadataMap(long platformId, string name)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@platformId", platformId },
+				{ "@name", name.Trim() }
+			};
+			DataTable dt = new DataTable();
+
+			sql = "SELECT Id FROM MetadataMap WHERE PlatformId = @platformId AND SignatureGameName = @name;";
+			dt = db.ExecuteCMD(sql, dbDict);
+
+			if (dt.Rows.Count > 0)
+			{
+				return GetMetadataMap((long)dt.Rows[0]["Id"]);
+			}
+
+			return null;
+		}
+
+		/// <summary>
+		/// Gets a metadata map from the database.
+		/// </summary>
+		/// <param name="metadataMapId">
+		/// The ID of the metadata map.
+		/// </param>
+		/// <returns>
+		/// The metadata map, or null if it does not exist.
+		/// </returns>
+		/// <remarks>
+		/// This method will return the metadata map with the given ID.
+		/// </remarks>
+		public static MetadataMap? GetMetadataMap(long metadataMapId)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@metadataMapId", metadataMapId }
+			};
+			DataTable dt = new DataTable();
+
+			sql = "SELECT * FROM MetadataMap WHERE Id = @metadataMapId;";
+			dt = db.ExecuteCMD(sql, dbDict);
+
+			if (dt.Rows.Count > 0)
+			{
+				MetadataMap metadataMap = new MetadataMap()
+				{
+					Id = (long)dt.Rows[0]["Id"],
+					PlatformId = (long)dt.Rows[0]["PlatformId"],
+					SignatureGameName = dt.Rows[0]["SignatureGameName"].ToString(),
+					MetadataMapItems = new List<MetadataMap.MetadataMapItem>()
+				};
+
+				sql = "SELECT * FROM MetadataMapBridge WHERE ParentMapId = @metadataMapId;";
+				dt = db.ExecuteCMD(sql, dbDict);
+
+				foreach (DataRow dr in dt.Rows)
+				{
+					MetadataMap.MetadataMapItem metadataMapItem = new MetadataMap.MetadataMapItem()
+					{
+						SourceType = (HasheousClient.Models.MetadataSources)dr["MetadataSourceType"],
+						SourceId = (long)dr["MetadataSourceId"],
+						Preferred = (bool)dr["Preferred"]
+					};
+
+					metadataMap.MetadataMapItems.Add(metadataMapItem);
+				}
+
+				return metadataMap;
+			}
+
+			return null;
+		}
+
+		public static void SetMetadataSupportData(long metadataMapId, MetadataMapSupportDataTypes dataType, string data)
+		{
+			// verify the metadata map exists
+			MetadataMap? metadataMap = GetMetadataMap(metadataMapId);
+			if (metadataMap == null)
+			{
+				return;
+			}
+
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@metadataMapId", metadataMapId },
+				{ "@data", data }
+			};
+
+			switch (dataType)
+			{
+				case MetadataMapSupportDataTypes.UserManualLink:
+					sql = "UPDATE MetadataMap SET UserManualLink = @data WHERE Id = @metadataMapId;";
+					db.ExecuteCMD(sql, dbDict);
+					break;
+			}
+		}
+
+		/// <summary>
+		/// Get the MetadataMapItem for the provided metadata source, and source id
+		/// </summary>
+		/// <param name="sourceType">
+		/// The type of the metadata source.
+		/// </param>
+		/// <param name="sourceId">
+		/// The ID of the metadata source.
+		/// </param>
+		/// <returns>
+		/// The MetadataMapItem, or null if it does not exist.
+		/// </returns>
+		/// <remarks>
+		/// This method will return the MetadataMapItem with the given sourceType and sourceId.
+		/// </remarks>
+		public static MetadataMap.MetadataMapItem? GetMetadataMapFromSourceId(HasheousClient.Models.MetadataSources sourceType, long sourceId)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@sourceType", sourceType },
+				{ "@sourceId", sourceId }
+			};
+			DataTable dt = new DataTable();
+
+			sql = "SELECT * FROM MetadataMapBridge WHERE MetadataSourceType = @sourceType AND MetadataSourceId = @sourceId;";
+			dt = db.ExecuteCMD(sql, dbDict);
+
+			if (dt.Rows.Count > 0)
+			{
+				MetadataMap.MetadataMapItem metadataMapItem = new MetadataMap.MetadataMapItem()
+				{
+					SourceType = (HasheousClient.Models.MetadataSources)dt.Rows[0]["MetadataSourceType"],
+					SourceId = (long)dt.Rows[0]["MetadataSourceId"],
+					Preferred = (bool)dt.Rows[0]["Preferred"]
+				};
+
+				return metadataMapItem;
+			}
+
+			return null;
+		}
+
+		/// <summary>
+		/// Get the Id of the MetadataMap for the provided metadata source, and source id
+		/// </summary>
+		/// <param name="sourceType">
+		/// The type of the metadata source.
+		/// </param>
+		/// <param name="sourceId">
+		/// The ID of the metadata source.
+		/// </param>
+		/// <returns>
+		/// The ID of the MetadataMap, or null if it does not exist.
+		/// </returns>
+		public static long? GetMetadataMapIdFromSourceId(HasheousClient.Models.MetadataSources sourceType, long sourceId)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>()
+			{
+				{ "@sourceType", sourceType },
+				{ "@sourceId", sourceId }
+			};
+			DataTable dt = new DataTable();
+
+			sql = "SELECT * FROM MetadataMapBridge WHERE MetadataSourceType = @sourceType AND MetadataSourceId = @sourceId;";
+			dt = db.ExecuteCMD(sql, dbDict);
+
+			if (dt.Rows.Count > 0)
+			{
+				return (long)dt.Rows[0]["ParentMapId"];
+			}
+
+			return null;
+		}
+
 		public void RefreshMetadata(bool forceRefresh = false)
 		{
 			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
@@ -15,7 +358,7 @@ namespace gaseous_server.Classes
 			// disabling forceRefresh
 			forceRefresh = false;
 
-			// update platforms
+			// update platform metadata
 			sql = "SELECT Id, `Name` FROM Platform;";
 			dt = db.ExecuteCMD(sql);
 
@@ -27,7 +370,23 @@ namespace gaseous_server.Classes
 				try
 				{
 					Logging.Log(Logging.LogType.Information, "Metadata Refresh", "(" + StatusCounter + "/" + dt.Rows.Count + "): Refreshing metadata for platform " + dr["name"] + " (" + dr["id"] + ")");
-					Metadata.Platforms.GetPlatform((long)dr["id"], true);
+
+					HasheousClient.Models.MetadataSources metadataSource = HasheousClient.Models.MetadataSources.None;
+
+					// fetch the platform metadata
+					Platform platform = Metadata.Platforms.GetPlatform((long)dr["id"], metadataSource);
+
+					// fetch the platform metadata from Hasheous
+					if (Config.MetadataConfiguration.SignatureSource == HasheousClient.Models.MetadataModel.SignatureSources.Hasheous)
+					{
+						Communications.PopulateHasheousPlatformData((long)dr["id"]);
+					}
+
+					// force platformLogo refresh
+					if (platform.PlatformLogo != null)
+					{
+						Metadata.PlatformLogos.GetPlatformLogo(platform.PlatformLogo, metadataSource);
+					}
 				}
 				catch (Exception ex)
 				{
@@ -38,7 +397,68 @@ namespace gaseous_server.Classes
 			}
 			ClearStatus();
 
-			// update games
+			// update rom signatures - only valid if Haseheous is enabled
+			if (Config.MetadataConfiguration.SignatureSource == MetadataModel.SignatureSources.Hasheous)
+			{
+				// get all ROMs in the database
+				sql = "SELECT * FROM view_Games_Roms;";
+				dt = db.ExecuteCMD(sql);
+
+				StatusCounter = 1;
+				foreach (DataRow dr in dt.Rows)
+				{
+					SetStatus(StatusCounter, dt.Rows.Count, "Refreshing signature for ROM " + dr["Name"]);
+
+					try
+					{
+						Logging.Log(Logging.LogType.Information, "Metadata Refresh", "(" + StatusCounter + "/" + dt.Rows.Count + "): Refreshing signature for ROM " + dr["Name"] + " (" + dr["Id"] + ")");
+
+						// get the hash of the ROM from the datarow
+						string? md5 = dr["MD5"] == DBNull.Value ? null : dr["MD5"].ToString();
+						string? sha1 = dr["SHA1"] == DBNull.Value ? null : dr["SHA1"].ToString();
+						Common.hashObject hash = new Common.hashObject();
+						if (md5 != null)
+						{
+							hash.md5hash = md5;
+						}
+						if (sha1 != null)
+						{
+							hash.sha1hash = sha1;
+						}
+
+						// get the library for the ROM
+						GameLibrary.LibraryItem library = GameLibrary.GetLibrary((int)dr["LibraryId"]);
+
+						// get the signature for the ROM
+						FileInfo fi = new FileInfo(dr["Path"].ToString());
+						FileSignature fileSignature = new FileSignature();
+						gaseous_server.Models.Signatures_Games signature = fileSignature.GetFileSignature(library, hash, fi, fi.FullName);
+
+						// validate the signature - if it is invalid, skip the rest of the loop
+						// validation rules: 1) signature must not be null, 2) signature must have a platform ID
+						if (signature == null || signature.Flags.PlatformId == null)
+						{
+							Logging.Log(Logging.LogType.Information, "Metadata Refresh", "Signature for " + dr["RomName"] + " is invalid - skipping metadata refresh");
+							StatusCounter += 1;
+							continue;
+						}
+
+						// update the signature in the database
+						Platform? signaturePlatform = Metadata.Platforms.GetPlatform((long)signature.Flags.PlatformId);
+						ImportGame.StoreGame(library, hash, signature, signaturePlatform, fi.FullName, (long)dr["Id"], false);
+					}
+					catch (Exception ex)
+					{
+						Logging.Log(Logging.LogType.Critical, "Metadata Refresh", "An error occurred while refreshing metadata for " + dr["RomName"], ex);
+					}
+
+					StatusCounter += 1;
+				}
+				ClearStatus();
+			}
+
+
+			// update game metadata
 			if (forceRefresh == true)
 			{
 				// when forced, only update games with ROMs for
@@ -47,7 +467,7 @@ namespace gaseous_server.Classes
 			else
 			{
 				// when run normally, update all games (since this will honour cache timeouts)
-				sql = "SELECT Id, `Name` FROM Game;";
+				sql = "SELECT DISTINCT MetadataSourceId AS `Id`, MetadataSourceType AS `GameIdType`, SignatureGameName AS `Name` FROM gaseous.view_MetadataMap;";
 			}
 			dt = db.ExecuteCMD(sql);
 
@@ -58,8 +478,111 @@ namespace gaseous_server.Classes
 
 				try
 				{
-					Logging.Log(Logging.LogType.Information, "Metadata Refresh", "(" + StatusCounter + "/" + dt.Rows.Count + "): Refreshing metadata for game " + dr["name"] + " (" + dr["id"] + ")");
-					Metadata.Games.GetGame((long)dr["id"], true, false, true);
+					MetadataSources metadataSource;
+					if (dr["GameIdType"] == DBNull.Value)
+					{
+						Logging.Log(Logging.LogType.Information, "Metadata Refresh", "(" + StatusCounter + "/" + dt.Rows.Count + "): Unable to refresh metadata for game " + dr["name"] + " (" + dr["id"] + ") - no source type specified");
+					}
+					else
+					{
+						metadataSource = (MetadataSources)Enum.Parse(typeof(MetadataSources), dr["GameIdType"].ToString());
+
+						Logging.Log(Logging.LogType.Information, "Metadata Refresh", "(" + StatusCounter + "/" + dt.Rows.Count + "): Refreshing metadata for game " + dr["name"] + " (" + dr["id"] + ") using source " + metadataSource.ToString());
+						HasheousClient.Models.Metadata.IGDB.Game game = Metadata.Games.GetGame(metadataSource, (long)dr["id"]);
+
+						// get supporting metadata
+						if (game != null)
+						{
+							if (game.AgeRatings != null)
+							{
+								foreach (long ageRatingId in game.AgeRatings)
+								{
+									AgeRating ageRating = Metadata.AgeRatings.GetAgeRating(metadataSource, ageRatingId);
+									if (ageRating.ContentDescriptions != null)
+									{
+										foreach (long ageRatingContentDescriptionId in ageRating.ContentDescriptions)
+										{
+											Metadata.AgeRatingContentDescriptions.GetAgeRatingContentDescriptions(metadataSource, ageRatingContentDescriptionId);
+										}
+									}
+								}
+							}
+							if (game.AlternativeNames != null)
+							{
+								foreach (long alternateNameId in game.AlternativeNames)
+								{
+									Metadata.AlternativeNames.GetAlternativeNames(metadataSource, alternateNameId);
+								}
+							}
+							if (game.Artworks != null)
+							{
+								foreach (long artworkId in game.Artworks)
+								{
+									Metadata.Artworks.GetArtwork(metadataSource, artworkId);
+								}
+							}
+							if (game.Cover != null)
+							{
+								Metadata.Covers.GetCover(metadataSource, (long?)game.Cover);
+							}
+							if (game.GameModes != null)
+							{
+								foreach (long gameModeId in game.GameModes)
+								{
+									Metadata.GameModes.GetGame_Modes(metadataSource, gameModeId);
+								}
+							}
+							if (game.Genres != null)
+							{
+								foreach (long genreId in game.Genres)
+								{
+									Metadata.Genres.GetGenres(metadataSource, genreId);
+								}
+							}
+							if (game.Videos != null)
+							{
+								foreach (long gameVideoId in game.Videos)
+								{
+									Metadata.GamesVideos.GetGame_Videos(metadataSource, gameVideoId);
+								}
+							}
+							if (game.MultiplayerModes != null)
+							{
+								foreach (long multiplayerModeId in game.MultiplayerModes)
+								{
+									Metadata.MultiplayerModes.GetGame_MultiplayerModes(metadataSource, multiplayerModeId);
+								}
+							}
+							if (game.PlayerPerspectives != null)
+							{
+								foreach (long playerPerspectiveId in game.PlayerPerspectives)
+								{
+									Metadata.PlayerPerspectives.GetGame_PlayerPerspectives(metadataSource, playerPerspectiveId);
+								}
+							}
+							if (game.ReleaseDates != null)
+							{
+								foreach (long releaseDateId in game.ReleaseDates)
+								{
+									Metadata.ReleaseDates.GetReleaseDates(metadataSource, releaseDateId);
+								}
+							}
+							if (game.Screenshots != null)
+							{
+								foreach (long screenshotId in game.Screenshots)
+								{
+									Metadata.Screenshots.GetScreenshot(metadataSource, screenshotId);
+								}
+							}
+							if (game.Themes != null)
+							{
+								foreach (long themeId in game.Themes)
+								{
+									Metadata.Themes.GetGame_Themes(metadataSource, themeId);
+								}
+							}
+						}
+					}
 				}
 				catch (Exception ex)
 				{

gaseous-server/Classes/RomMediaGroup.cs

@@ -2,9 +2,12 @@ using System;
 using System.Data;
 using gaseous_signature_parser.models.RomSignatureObject;
 using Microsoft.VisualBasic;
-using IGDB.Models;
 using gaseous_server.Classes.Metadata;
 using System.IO.Compression;
+using SharpCompress.Archives;
+using SharpCompress.Common;
+using gaseous_server.Models;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Classes
 {
@@ -78,14 +81,42 @@ namespace gaseous_server.Classes
             }
         }
 
-        public static List<GameRomMediaGroupItem> GetMediaGroupsFromGameId(long GameId, string userid = "")
+        public static List<GameRomMediaGroupItem> GetMediaGroupsFromGameId(long GameId, string userid = "", long? PlatformId = null)
         {
+            string PlatformWhereClause = "";
+            if (PlatformId != null)
+            {
+                PlatformWhereClause = " AND RomMediaGroup.PlatformId=@platformid";
+            }
+
+            string UserFields = "";
+            string UserJoin = "";
+            if (userid.Length > 0)
+            {
+                UserFields = ", User_RecentPlayedRoms.RomId AS MostRecentRomId, User_RecentPlayedRoms.IsMediaGroup AS MostRecentRomIsMediaGroup, User_GameFavouriteRoms.RomId AS FavouriteRomId, User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup";
+                UserJoin = @"
+					LEFT JOIN
+				User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
+					AND User_RecentPlayedRoms.GameId = RomMediaGroup.GameId
+					AND User_RecentPlayedRoms.PlatformId = RomMediaGroup.PlatformId
+                    AND User_RecentPlayedRoms.RomId = RomMediaGroup.Id
+					AND User_RecentPlayedRoms.IsMediaGroup = 1
+					LEFT JOIN
+				User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
+					AND User_GameFavouriteRoms.GameId = RomMediaGroup.GameId
+					AND User_GameFavouriteRoms.PlatformId = RomMediaGroup.PlatformId
+                    AND User_GameFavouriteRoms.RomId = RomMediaGroup.Id
+					AND User_GameFavouriteRoms.IsMediaGroup = 1
+				";
+            }
+
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT DISTINCT RomMediaGroup.*, GameState.RomId AS GameStateRomId FROM gaseous.RomMediaGroup LEFT JOIN GameState ON RomMediaGroup.Id = GameState.RomId AND GameState.IsMediaGroup = 1 AND GameState.UserId = @userid WHERE RomMediaGroup.GameId=@gameid;";
+            string sql = "SELECT DISTINCT RomMediaGroup.*, GameState.RomId AS GameStateRomId" + UserFields + " FROM gaseous.RomMediaGroup LEFT JOIN GameState ON RomMediaGroup.Id = GameState.RomId AND GameState.IsMediaGroup = 1 AND GameState.UserId = @userid " + UserJoin + " WHERE RomMediaGroup.GameId=@gameid" + PlatformWhereClause + ";";
             Dictionary<string, object> dbDict = new Dictionary<string, object>
             {
                 { "gameid", GameId },
-                { "userid", userid }
+                { "userid", userid },
+                { "platformid", PlatformId }
             };
 
             DataTable dataTable = db.ExecuteCMD(sql, dbDict);
@@ -162,7 +193,7 @@ namespace gaseous_server.Classes
         public static void DeleteMediaGroup(long Id)
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "DELETE FROM RomMediaGroup WHERE Id=@id; DELETE FROM GameState WHERE RomId=@id AND IsMediaGroup=1;";
+            string sql = "DELETE FROM RomMediaGroup WHERE Id=@id; DELETE FROM GameState WHERE RomId=@id AND IsMediaGroup=1; DELETE FROM User_GameFavouriteRoms WHERE RomId = @id AND IsMediaGroup = 1; DELETE FROM User_RecentPlayedRoms WHERE RomId = @id AND IsMediaGroup = 1; UPDATE UserTimeTracking SET PlatformId = NULL, IsMediaGroup = NULL, RomId = NULL WHERE RomId=@id AND IsMediaGroup = 1;";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             dbDict.Add("id", Id);
             db.ExecuteCMD(sql, dbDict);
@@ -185,14 +216,34 @@ namespace gaseous_server.Classes
                 }
             }
 
-            GameRomMediaGroupItem mediaGroupItem = new GameRomMediaGroupItem();
-            mediaGroupItem.Id = (long)row["Id"];
-            mediaGroupItem.Status = (GameRomMediaGroupItem.GroupBuildStatus)row["Status"];
-            mediaGroupItem.PlatformId = (long)row["PlatformId"];
-            mediaGroupItem.GameId = (long)row["GameId"];
-            mediaGroupItem.RomIds = new List<long>();
-            mediaGroupItem.Roms = new List<Roms.GameRomItem>();
-            mediaGroupItem.HasSaveStates = hasSaveStates;
+            GameRomMediaGroupItem mediaGroupItem = new GameRomMediaGroupItem
+            {
+                Id = (long)row["Id"],
+                Status = (GameRomMediaGroupItem.GroupBuildStatus)row["Status"],
+                PlatformId = (long)row["PlatformId"],
+                GameId = (long)row["GameId"],
+                RomIds = new List<long>(),
+                Roms = new List<Roms.GameRomItem>(),
+                HasSaveStates = hasSaveStates
+            };
+
+            mediaGroupItem.RomUserLastUsed = false;
+            if (row.Table.Columns.Contains("MostRecentRomId"))
+            {
+                if (row["MostRecentRomId"] != DBNull.Value)
+                {
+                    mediaGroupItem.RomUserLastUsed = true;
+                }
+            }
+
+            mediaGroupItem.RomUserFavourite = false;
+            if (row.Table.Columns.Contains("FavouriteRomId"))
+            {
+                if (row["FavouriteRomId"] != DBNull.Value)
+                {
+                    mediaGroupItem.RomUserFavourite = true;
+                }
+            }
 
             // get members
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
@@ -213,18 +264,6 @@ namespace gaseous_server.Classes
                 }
             }
 
-            // check for a web emulator and update the romItem
-			foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
-			{
-				if (platformMapping.IGDBId == mediaGroupItem.PlatformId)
-				{
-					if (platformMapping.WebEmulator != null)
-					{
-						mediaGroupItem.Emulator = platformMapping.WebEmulator;
-					}
-				}
-			}
-
             return mediaGroupItem;
         }
 
@@ -257,8 +296,10 @@ namespace gaseous_server.Classes
             GameRomMediaGroupItem mediaGroupItem = GetMediaGroup(Id);
             if (mediaGroupItem.Status == GameRomMediaGroupItem.GroupBuildStatus.WaitingForBuild)
             {
-                Game GameObject = Games.GetGame(mediaGroupItem.GameId, false, false, false);
-                Platform PlatformObject = Platforms.GetPlatform(mediaGroupItem.PlatformId, false);
+                MetadataMap.MetadataMapItem metadataMap = Classes.MetadataManagement.GetMetadataMap(mediaGroupItem.GameId).PreferredMetadataMapItem;
+                Models.Game GameObject = Games.GetGame(metadataMap.SourceType, metadataMap.SourceId);
+                Platform PlatformObject = Platforms.GetPlatform(mediaGroupItem.PlatformId);
+                PlatformMapping.PlatformMapItem platformMapItem = PlatformMapping.GetPlatformMap(mediaGroupItem.PlatformId);
 
                 Logging.Log(Logging.LogType.Information, "Media Group", "Beginning build of media group: " + GameObject.Name + " for platform " + PlatformObject.Name);
 
@@ -293,10 +334,124 @@ namespace gaseous_server.Classes
                     foreach (long RomId in mediaGroupItem.RomIds)
                     {
                         Roms.GameRomItem rom = Roms.GetRom(RomId);
+                        bool fileNameFound = false;
                         if (File.Exists(rom.Path))
                         {
+                            string romExt = Path.GetExtension(rom.Path);
+                            if (new string[] { ".zip", ".rar", ".7z" }.Contains(romExt))
+                            {
+                                Logging.Log(Logging.LogType.Information, "Media Group", "Decompressing ROM: " + rom.Name);
+
+                                // is compressed
+                                switch (romExt)
+                                {
+                                    case ".zip":
+                                        try
+                                        {
+                                            using (var archive = SharpCompress.Archives.Zip.ZipArchive.Open(rom.Path))
+                                            {
+                                                foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+                                                {
+                                                    Logging.Log(Logging.LogType.Information, "Media Group", "Extracting file: " + entry.Key);
+                                                    if (fileNameFound == false)
+                                                    {
+                                                        //check if extension is in valid extensions
+                                                        if (platformMapItem.Extensions.SupportedFileExtensions.Contains(Path.GetExtension(entry.Key), StringComparer.InvariantCultureIgnoreCase))
+                                                        {
+                                                            // update rom file name
+                                                            rom.Name = entry.Key;
+                                                            fileNameFound = true;
+                                                        }
+                                                    }
+                                                    entry.WriteToDirectory(ZipFileTempPath, new ExtractionOptions()
+                                                    {
+                                                        ExtractFullPath = true,
+                                                        Overwrite = true
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        catch (Exception zipEx)
+                                        {
+                                            Logging.Log(Logging.LogType.Warning, "Media Group", "Unzip error", zipEx);
+                                            throw;
+                                        }
+                                        break;
+
+                                    case ".rar":
+                                        try
+                                        {
+                                            using (var archive = SharpCompress.Archives.Rar.RarArchive.Open(rom.Path))
+                                            {
+                                                foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+                                                {
+                                                    Logging.Log(Logging.LogType.Information, "Media Group", "Extracting file: " + entry.Key);
+                                                    if (fileNameFound == false)
+                                                    {
+                                                        //check if extension is in valid extensions
+                                                        if (platformMapItem.Extensions.SupportedFileExtensions.Contains(Path.GetExtension(entry.Key), StringComparer.InvariantCultureIgnoreCase))
+                                                        {
+                                                            // update rom file name
+                                                            rom.Name = entry.Key;
+                                                            fileNameFound = true;
+                                                        }
+                                                    }
+                                                    entry.WriteToDirectory(ZipFileTempPath, new ExtractionOptions()
+                                                    {
+                                                        ExtractFullPath = true,
+                                                        Overwrite = true
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        catch (Exception zipEx)
+                                        {
+                                            Logging.Log(Logging.LogType.Warning, "Media Group", "Unrar error", zipEx);
+                                            throw;
+                                        }
+                                        break;
+
+                                    case ".7z":
+                                        try
+                                        {
+                                            using (var archive = SharpCompress.Archives.SevenZip.SevenZipArchive.Open(rom.Path))
+                                            {
+                                                foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+                                                {
+                                                    Logging.Log(Logging.LogType.Information, "Media Group", "Extracting file: " + entry.Key);
+                                                    if (fileNameFound == false)
+                                                    {
+                                                        //check if extension is in valid extensions
+                                                        if (platformMapItem.Extensions.SupportedFileExtensions.Contains(Path.GetExtension(entry.Key), StringComparer.InvariantCultureIgnoreCase))
+                                                        {
+                                                            // update rom file name
+                                                            rom.Name = entry.Key;
+                                                            fileNameFound = true;
+                                                        }
+                                                    }
+                                                    entry.WriteToDirectory(ZipFileTempPath, new ExtractionOptions()
+                                                    {
+                                                        ExtractFullPath = true,
+                                                        Overwrite = true
+                                                    });
+                                                }
+                                            }
+                                        }
+                                        catch (Exception zipEx)
+                                        {
+                                            Logging.Log(Logging.LogType.Warning, "Media Group", "7z error", zipEx);
+                                            throw;
+                                        }
+                                        break;
+
+                                }
+                            }
+                            else
+                            {
+                                // is uncompressed
                                 Logging.Log(Logging.LogType.Information, "Media Group", "Copying ROM: " + rom.Name);
                                 File.Copy(rom.Path, Path.Combine(ZipFileTempPath, Path.GetFileName(rom.Path)));
+                            }
 
                             romItems.Add(rom);
                         }
@@ -397,12 +552,13 @@ namespace gaseous_server.Classes
             public long Id { get; set; }
             public long GameId { get; set; }
             public long PlatformId { get; set; }
-            public string Platform {
+            public string Platform
+            {
                 get
                 {
                     try
                     {
-                        return Platforms.GetPlatform(PlatformId, false).Name;
+                        return Platforms.GetPlatform(PlatformId).Name;
                     }
                     catch
                     {
@@ -410,12 +566,14 @@ namespace gaseous_server.Classes
                     }
                 }
             }
-            public Models.PlatformMapping.PlatformMapItem.WebEmulatorItem? Emulator { get; set; }
             public List<long> RomIds { get; set; }
             public List<Roms.GameRomItem> Roms { get; set; }
             public bool HasSaveStates { get; set; } = false;
+            public bool RomUserLastUsed { get; set; }
+            public bool RomUserFavourite { get; set; }
             private GroupBuildStatus _Status { get; set; }
-			public GroupBuildStatus Status {
+            public GroupBuildStatus Status
+            {
                 get
                 {
                     if (_Status == GroupBuildStatus.Completed)
@@ -439,7 +597,8 @@ namespace gaseous_server.Classes
                     _Status = value;
                 }
             }
-			public long? Size {
+            public long? Size
+            {
                 get
                 {
                     if (Status == GroupBuildStatus.Completed)

gaseous-server/Classes/Roms.cs

@@ -3,7 +3,9 @@ using System.Data;
 using gaseous_signature_parser.models.RomSignatureObject;
 using static gaseous_server.Classes.RomMediaGroup;
 using gaseous_server.Classes.Metadata;
-using IGDB.Models;
+using static HasheousClient.Models.FixMatchModel;
+using NuGet.Protocol.Core.Types;
+using static gaseous_server.Classes.FileSignature;
 
 namespace gaseous_server.Classes
 {
@@ -15,6 +17,12 @@ namespace gaseous_server.Classes
 			{ }
 		}
 
+		public class InvalidRomHash : Exception
+		{
+			public InvalidRomHash(String Hash) : base("Unable to find ROM by hash " + Hash)
+			{ }
+		}
+
 		public static GameRomObject GetRoms(long GameId, long PlatformId = -1, string NameSearch = "", int pageNumber = 0, int pageSize = 0, string userid = "")
 		{
 			GameRomObject GameRoms = new GameRomObject();
@@ -34,40 +42,88 @@ namespace gaseous_server.Classes
 				dbDict.Add("namesearch", '%' + NameSearch + '%');
 			}
 
+			string UserFields = "";
+			string UserJoin = "";
+			if (userid.Length > 0)
+			{
+				UserFields = ", User_RecentPlayedRoms.RomId AS MostRecentRomId, User_RecentPlayedRoms.IsMediaGroup AS MostRecentRomIsMediaGroup, User_GameFavouriteRoms.RomId AS FavouriteRomId, User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup";
+				UserJoin = @"
+					LEFT JOIN
+				User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
+					AND User_RecentPlayedRoms.GameId = Games_Roms.MetadataMapId
+					AND User_RecentPlayedRoms.PlatformId = Games_Roms.PlatformId
+					AND User_RecentPlayedRoms.RomId = Games_Roms.Id
+					AND User_RecentPlayedRoms.IsMediaGroup = 0
+					LEFT JOIN
+				User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
+					AND User_GameFavouriteRoms.GameId = Games_Roms.MetadataMapId
+					AND User_GameFavouriteRoms.PlatformId = Games_Roms.PlatformId
+					AND User_GameFavouriteRoms.RomId = Games_Roms.Id
+					AND User_GameFavouriteRoms.IsMediaGroup = 0
+				";
+			}
+
 			// platform query
 			sqlPlatform = "SELECT DISTINCT Games_Roms.PlatformId, Platform.`Name` FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE GameId = @id ORDER BY Platform.`Name`;";
 
-			if (PlatformId == -1) {
+			if (PlatformId == -1)
+			{
 				// data query
-				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, GameState.RomId AS SavedStateRomId FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) WHERE Games_Roms.GameId = @id" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+				sql = "SELECT DISTINCT view_Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename, GameState.RomId AS SavedStateRomId" + UserFields + " FROM view_Games_Roms LEFT JOIN Platform ON view_Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON view_Games_Roms.GameId = Game.Id LEFT JOIN GameState ON (view_Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) " + UserJoin + " WHERE view_Games_Roms.MetadataMapId = @id" + NameSearchWhere + " ORDER BY Platform.`Name`, view_Games_Roms.`Name`;";
 
 				// count query
-				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id" + NameSearchWhere + ";";
-			} else {
+				sqlCount = "SELECT COUNT(view_Games_Roms.Id) AS RomCount FROM view_Games_Roms WHERE view_Games_Roms.MetadataMapId = @id" + NameSearchWhere + ";";
+			}
+			else
+			{
 				// data query
-				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, GameState.RomId AS SavedStateRomId FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+				sql = @"
+				SELECT DISTINCT
+					Games_Roms.*,
+					Platform.`Name` AS platformname,
+					view_GamesWithRoms.`Name` AS gamename,
+					GameState.RomId AS SavedStateRomId,
+					CONCAT(`GameLibraries`.`Path`,
+						'/',
+						`Games_Roms`.`RelativePath`) AS `Path`,
+					`GameLibraries`.`Name` AS `LibraryName`
+					" + UserFields + @"
+				FROM
+					Games_Roms
+				JOIN
+					GameLibraries ON Games_Roms.LibraryId = GameLibraries.Id
+				LEFT JOIN
+					Platform ON Games_Roms.PlatformId = Platform.Id AND Platform.SourceId = @platformsource
+				LEFT JOIN
+					view_GamesWithRoms ON view_GamesWithRoms.MetadataMapId = Games_Roms.MetadataMapId
+				LEFT JOIN
+					GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) " + UserJoin + @"
+				WHERE
+					Games_Roms.MetadataMapId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + @"
+				ORDER BY
+					Platform.`Name`, Games_Roms.`Name`;
+				";
 
 				// count query
-				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + ";";
+				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.MetadataMapId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + ";";
 
 				dbDict.Add("platformid", PlatformId);
+				dbDict.Add("platformsource", (int)HasheousClient.Models.MetadataSources.None);
 			}
-            DataTable romDT = db.ExecuteCMD(sql, dbDict);
-			Dictionary<string, object> rowCount = db.ExecuteCMDDict(sqlCount, dbDict)[0];
-			DataTable platformDT = db.ExecuteCMD(sqlPlatform, dbDict);
+			DataTable romDT = db.ExecuteCMD(sql, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromMinutes(1).Ticks));
 
 			if (romDT.Rows.Count > 0)
 			{
 				// set count of roms
+				Dictionary<string, object> rowCount = db.ExecuteCMDDict(sqlCount, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromMinutes(1).Ticks))[0];
 				GameRoms.Count = int.Parse((string)rowCount["RomCount"]);
 
 				int pageOffset = pageSize * (pageNumber - 1);
 				for (int i = 0; i < romDT.Rows.Count; i++)
 				{
-					GameRomItem gameRomItem = BuildRom(romDT.Rows[i]);
-
 					if ((i >= pageOffset && i < pageOffset + pageSize) || pageSize == 0)
 					{
+						GameRomItem gameRomItem = BuildRom(romDT.Rows[i]);
 						GameRoms.GameRomItems.Add(gameRomItem);
 					}
 				}
@@ -83,7 +139,7 @@ namespace gaseous_server.Classes
 		public static GameRomItem GetRom(long RomId)
 		{
 			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql = "SELECT Games_Roms.*, Platform.`Name` AS platformname FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE Games_Roms.Id = @id";
+			string sql = "SELECT DISTINCT view_Games_Roms.*, Platform.`Name` AS platformname, view_GamesWithRoms.`Name` AS gamename FROM view_Games_Roms LEFT JOIN Platform ON view_Games_Roms.PlatformId = Platform.Id LEFT JOIN view_GamesWithRoms ON view_Games_Roms.MetadataMapId = view_GamesWithRoms.MetadataMapId WHERE view_Games_Roms.Id = @id";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
 			dbDict.Add("id", RomId);
 			DataTable romDT = db.ExecuteCMD(sql, dbDict);
@@ -100,16 +156,36 @@ namespace gaseous_server.Classes
 			}
 		}
 
+		public static GameRomItem GetRom(string MD5)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT DISTINCT view_Games_Roms.*, Platform.`Name` AS platformname, view_GamesWithRoms.`Name` AS gamename FROM view_Games_Roms LEFT JOIN Platform ON view_Games_Roms.PlatformId = Platform.Id LEFT JOIN view_GamesWithRoms ON view_Games_Roms.MetadataMapId = view_GamesWithRoms.MetadataMapId WHERE view_Games_Roms.MD5 = @id";
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			dbDict.Add("id", MD5);
+			DataTable romDT = db.ExecuteCMD(sql, dbDict);
+
+			if (romDT.Rows.Count > 0)
+			{
+				DataRow romDR = romDT.Rows[0];
+				GameRomItem romItem = BuildRom(romDR);
+				return romItem;
+			}
+			else
+			{
+				throw new InvalidRomHash(MD5);
+			}
+		}
+
 		public static GameRomItem UpdateRom(long RomId, long PlatformId, long GameId)
 		{
 			// ensure metadata for platformid is present
-			IGDB.Models.Platform platform = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+			HasheousClient.Models.Metadata.IGDB.Platform platform = Classes.Metadata.Platforms.GetPlatform(PlatformId);
 
 			// ensure metadata for gameid is present
-			IGDB.Models.Game game = Classes.Metadata.Games.GetGame(GameId, false, false, false);
+			Models.Game game = Classes.Metadata.Games.GetGame(HasheousClient.Models.MetadataSources.IGDB, GameId);
 
 			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid WHERE Id = @id";
+			string sql = "UPDATE Games_Roms SET PlatformId=@platformid, MetadataMapId=@gameid WHERE Id = @id";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
 			dbDict.Add("id", RomId);
 			dbDict.Add("platformid", PlatformId);
@@ -118,6 +194,54 @@ namespace gaseous_server.Classes
 
 			GameRomItem rom = GetRom(RomId);
 
+			// send update to Hasheous if enabled
+			if (PlatformId != 0 && GameId != 0)
+			{
+				if (Config.MetadataConfiguration.HasheousSubmitFixes == true)
+				{
+					if (
+						Config.MetadataConfiguration.SignatureSource == HasheousClient.Models.MetadataModel.SignatureSources.Hasheous &&
+						(
+							Config.MetadataConfiguration.HasheousAPIKey != null &&
+							Config.MetadataConfiguration.HasheousAPIKey != "")
+						)
+					{
+						try
+						{
+							// find signature used for identifing the rom
+							string md5String = rom.Md5;
+							string sha1String = rom.Sha1;
+							if (rom.Attributes.ContainsKey("ZipContents"))
+							{
+								bool selectorFound = false;
+								List<ArchiveData> archiveDataValues = Newtonsoft.Json.JsonConvert.DeserializeObject<List<ArchiveData>>(rom.Attributes["ZipContents"].ToString());
+								foreach (ArchiveData archiveData in archiveDataValues)
+								{
+									if (archiveData.isSignatureSelector == true)
+									{
+										md5String = archiveData.MD5;
+										sha1String = archiveData.SHA1;
+										selectorFound = true;
+										break;
+									}
+								}
+							}
+
+							HasheousClient.WebApp.HttpHelper.APIKey = Config.MetadataConfiguration.HasheousAPIKey;
+							HasheousClient.WebApp.HttpHelper.ClientKey = Config.MetadataConfiguration.HasheousClientAPIKey;
+							HasheousClient.Hasheous hasheousClient = new HasheousClient.Hasheous();
+							List<MetadataMatch> metadataMatchList = new List<MetadataMatch>();
+							metadataMatchList.Add(new MetadataMatch(HasheousClient.Models.MetadataSources.IGDB, platform.Slug, game.Slug));
+							hasheousClient.FixMatch(new HasheousClient.Models.FixMatchModel(md5String, sha1String, metadataMatchList));
+						}
+						catch (Exception ex)
+						{
+							Logging.Log(Logging.LogType.Critical, "Fix Match", "An error occurred while sending a fixed match to Hasheous.", ex);
+						}
+					}
+				}
+			}
+
 			return rom;
 		}
 
@@ -132,7 +256,7 @@ namespace gaseous_server.Classes
 				}
 
 				Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-				string sql = "DELETE FROM Games_Roms WHERE Id = @id; DELETE FROM GameState WHERE RomId = @id;";
+				string sql = "DELETE FROM Games_Roms WHERE Id = @id; DELETE FROM GameState WHERE RomId = @id; DELETE FROM User_GameFavouriteRoms WHERE RomId = @id AND IsMediaGroup = 0; DELETE FROM User_RecentPlayedRoms WHERE RomId = @id AND IsMediaGroup = 0; UPDATE UserTimeTracking SET PlatformId = NULL, IsMediaGroup = NULL, RomId = NULL WHERE RomId = @id AND IsMediaGroup = 0;";
 				Dictionary<string, object> dbDict = new Dictionary<string, object>();
 				dbDict.Add("id", RomId);
 				db.ExecuteCMD(sql, dbDict);
@@ -150,39 +274,65 @@ namespace gaseous_server.Classes
 				}
 			}
 
+			Dictionary<string, object> romAttributes = new Dictionary<string, object>();
+			if (romDR["attributes"] != DBNull.Value)
+			{
+				try
+				{
+					if ((string)romDR["attributes"] != "[ ]")
+					{
+						romAttributes = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>((string)romDR["attributes"]);
+					}
+				}
+				catch (Exception ex)
+				{
+					Logging.Log(Logging.LogType.Warning, "Roms", "Error parsing rom attributes: " + ex.Message);
+				}
+			}
+
 			GameRomItem romItem = new GameRomItem
 			{
 				Id = (long)romDR["id"],
 				PlatformId = (long)romDR["platformid"],
 				Platform = (string)romDR["platformname"],
+				MetadataMapId = (long)romDR["metadatamapid"],
+				MetadataSource = (HasheousClient.Models.MetadataSources)(int)romDR["metadatasource"],
 				GameId = (long)romDR["gameid"],
+				Game = (string)Common.ReturnValueIfNull(romDR["gamename"], ""),
 				Name = (string)romDR["name"],
 				Size = (long)romDR["size"],
 				Crc = ((string)romDR["crc"]).ToLower(),
 				Md5 = ((string)romDR["md5"]).ToLower(),
 				Sha1 = ((string)romDR["sha1"]).ToLower(),
 				DevelopmentStatus = (string)romDR["developmentstatus"],
-                Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<List<KeyValuePair<string, object>>>((string)Common.ReturnValueIfNull(romDR["attributes"], "[ ]")),
-                RomType = (HasheousClient.Models.LookupResponseModel.RomItem.RomTypes)(int)romDR["romtype"],
+				Attributes = romAttributes,
+				RomType = (HasheousClient.Models.SignatureModel.RomItem.RomTypes)(int)romDR["romtype"],
 				RomTypeMedia = (string)romDR["romtypemedia"],
 				MediaLabel = (string)romDR["medialabel"],
 				Path = (string)romDR["path"],
+				RelativePath = (string)romDR["relativepath"],
 				SignatureSource = (gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType)(Int32)romDR["metadatasource"],
 				SignatureSourceGameTitle = (string)Common.ReturnValueIfNull(romDR["MetadataGameName"], ""),
 				HasSaveStates = hasSaveStates,
 				Library = GameLibrary.GetLibrary((int)romDR["LibraryId"])
 			};
 
-			// check for a web emulator and update the romItem
-			foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
+			romItem.RomUserLastUsed = false;
+			if (romDR.Table.Columns.Contains("MostRecentRomId"))
 			{
-				if (platformMapping.IGDBId == romItem.PlatformId)
+				if (romDR["MostRecentRomId"] != DBNull.Value)
 				{
-					if (platformMapping.WebEmulator != null)
-					{
-						romItem.Emulator = platformMapping.WebEmulator;
+					romItem.RomUserLastUsed = true;
 				}
 			}
+
+			romItem.RomUserFavourite = false;
+			if (romDR.Table.Columns.Contains("FavouriteRomId"))
+			{
+				if (romDR["FavouriteRomId"] != DBNull.Value)
+				{
+					romItem.RomUserFavourite = true;
+				}
 			}
 
 			return romItem;
@@ -194,16 +344,21 @@ namespace gaseous_server.Classes
 			public int Count { get; set; }
 		}
 
-		public class GameRomItem : HasheousClient.Models.LookupResponseModel.RomItem
+		public class GameRomItem : HasheousClient.Models.SignatureModel.RomItem
 		{
 			public long PlatformId { get; set; }
 			public string Platform { get; set; }
-            public Models.PlatformMapping.PlatformMapItem.WebEmulatorItem? Emulator { get; set; }
+			public long MetadataMapId { get; set; }
+			public HasheousClient.Models.MetadataSources MetadataSource { get; set; }
 			public long GameId { get; set; }
+			public string Game { get; set; }
 			public string? Path { get; set; }
+			public string? RelativePath { get; set; }
 			public string? SignatureSourceGameTitle { get; set; }
 			public bool HasSaveStates { get; set; } = false;
 			public GameLibrary.LibraryItem Library { get; set; }
+			public bool RomUserLastUsed { get; set; }
+			public bool RomUserFavourite { get; set; }
 		}
 	}
 }

gaseous-server/Classes/SignatureIngestors/XML.cs

@@ -8,21 +8,49 @@ namespace gaseous_server.SignatureIngestors.XML
 {
     public class XMLIngestor : QueueItemStatus
     {
-        public void Import(string SearchPath, gaseous_signature_parser.parser.SignatureParser XMLType)
+        public void Import(string SearchPath, string ProcessedDirectory, gaseous_signature_parser.parser.SignatureParser XMLType)
         {
             // connect to database
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
+            string? XMLDBSearchPath = null;
+            string? XMLDBProcessedDirectory = null;
+            if (XMLType == gaseous_signature_parser.parser.SignatureParser.NoIntro)
+            {
+                XMLDBSearchPath = Path.Combine(SearchPath, "DB");
+                XMLDBProcessedDirectory = Path.Combine(ProcessedDirectory, "DB");
+                SearchPath = Path.Combine(SearchPath, "DAT");
+                ProcessedDirectory = Path.Combine(ProcessedDirectory, "DAT");
+            }
+
             // process provided files
-            Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Importing from " + SearchPath);
             if (!Directory.Exists(SearchPath))
             {
                 Directory.CreateDirectory(SearchPath);
             }
+            if (!Directory.Exists(ProcessedDirectory))
+            {
+                Directory.CreateDirectory(ProcessedDirectory);
+            }
 
             string[] PathContents = Directory.GetFiles(SearchPath);
             Array.Sort(PathContents);
 
+            string[]? DBPathContents = null;
+            if (XMLDBSearchPath != null)
+            {
+                if (!Directory.Exists(XMLDBSearchPath))
+                {
+                    Directory.CreateDirectory(XMLDBSearchPath);
+                }
+                if (!Directory.Exists(XMLDBProcessedDirectory))
+                {
+                    Directory.CreateDirectory(XMLDBProcessedDirectory);
+                }
+
+                DBPathContents = Directory.GetFiles(XMLDBSearchPath);
+            }
+
             string sql = "";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             System.Data.DataTable sigDB;
@@ -33,12 +61,28 @@ namespace gaseous_server.SignatureIngestors.XML
 
                 SetStatus(i + 1, PathContents.Length, "Processing signature file: " + XMLFile);
 
-                if (Common.SkippableFiles.Contains(Path.GetFileName(XMLFile), StringComparer.OrdinalIgnoreCase))
+                Logging.Log(Logging.LogType.Information, "Signature Ingest", "(" + (i + 1) + " / " + PathContents.Length + ") Processing " + XMLType.ToString() + " DAT file: " + XMLFile);
+
+                string? DBFile = null;
+                if (XMLDBSearchPath != null)
                 {
-                    Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Skipping file: " + XMLFile);
+                    switch (XMLType)
+                    {
+                        case gaseous_signature_parser.parser.SignatureParser.NoIntro:
+                            for (UInt16 x = 0; x < DBPathContents.Length; x++)
+                            {
+                                string tempDBFileName = Path.GetFileNameWithoutExtension(DBPathContents[x].Replace(" (DB Export)", ""));
+                                if (tempDBFileName == Path.GetFileNameWithoutExtension(XMLFile))
+                                {
+                                    DBFile = DBPathContents[x];
+                                    Logging.Log(Logging.LogType.Information, "Signature Ingest", "Using DB file: " + DBFile);
+                                    break;
                                 }
-                else
-                {
+                            }
+                            break;
+                    }
+                }
+
                 // check xml file md5
                 Common.hashObject hashObject = new Common.hashObject(XMLFile);
                 sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
@@ -50,11 +94,9 @@ namespace gaseous_server.SignatureIngestors.XML
                 {
                     try
                     {
-                            Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Importing file: " + XMLFile);
-
                         // start parsing file
                         gaseous_signature_parser.parser Parser = new gaseous_signature_parser.parser();
-                            RomSignatureObject Object = Parser.ParseSignatureDAT(XMLFile, XMLType);
+                        RomSignatureObject Object = Parser.ParseSignatureDAT(XMLFile, DBFile, XMLType);
 
                         // store in database
                         string[] flipNameAndDescription = {
@@ -66,21 +108,27 @@ namespace gaseous_server.SignatureIngestors.XML
                         bool processGames = false;
                         if (Object.SourceMd5 != null)
                         {
-                                sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
-                                dbDict = new Dictionary<string, object>();
-                                string sourceUriStr = "";
-                                if (Object.Url != null)
+                            int sourceId = 0;
+
+                            sql = "SELECT * FROM Signatures_Sources WHERE `SourceMD5`=@sourcemd5";
+                            dbDict = new Dictionary<string, object>
                             {
-                                    sourceUriStr = Object.Url.ToString();
+                                { "name", Common.ReturnValueIfNull(Object.Name, "") },
+                                { "description", Common.ReturnValueIfNull(Object.Description, "") },
+                                { "category", Common.ReturnValueIfNull(Object.Category, "") },
+                                { "version", Common.ReturnValueIfNull(Object.Version, "") },
+                                { "author", Common.ReturnValueIfNull(Object.Author, "") },
+                                { "email", Common.ReturnValueIfNull(Object.Email, "") },
+                                { "homepage", Common.ReturnValueIfNull(Object.Homepage, "") }
+                            };
+                            if (Object.Url == null)
+                            {
+                                dbDict.Add("uri", "");
+                            }
+                            else
+                            {
+                                dbDict.Add("uri", Common.ReturnValueIfNull(Object.Url.ToString(), ""));
                             }
-                                dbDict.Add("name", Common.ReturnValueIfNull(Object.Name, ""));
-                                dbDict.Add("description", Common.ReturnValueIfNull(Object.Description, ""));
-                                dbDict.Add("category", Common.ReturnValueIfNull(Object.Category, ""));
-                                dbDict.Add("version", Common.ReturnValueIfNull(Object.Version, ""));
-                                dbDict.Add("author", Common.ReturnValueIfNull(Object.Author, ""));
-                                dbDict.Add("email", Common.ReturnValueIfNull(Object.Email, ""));
-                                dbDict.Add("homepage", Common.ReturnValueIfNull(Object.Homepage, ""));
-                                dbDict.Add("uri", sourceUriStr);
                             dbDict.Add("sourcetype", Common.ReturnValueIfNull(Object.SourceType, ""));
                             dbDict.Add("sourcemd5", Object.SourceMd5);
                             dbDict.Add("sourcesha1", Object.SourceSHA1);
@@ -89,9 +137,11 @@ namespace gaseous_server.SignatureIngestors.XML
                             if (sigDB.Rows.Count == 0)
                             {
                                 // entry not present, insert it
-                                    sql = "INSERT INTO Signatures_Sources (Name, Description, Category, Version, Author, Email, Homepage, Url, SourceType, SourceMD5, SourceSHA1) VALUES (@name, @description, @category, @version, @author, @email, @homepage, @uri, @sourcetype, @sourcemd5, @sourcesha1)";
+                                sql = "INSERT INTO Signatures_Sources (`Name`, `Description`, `Category`, `Version`, `Author`, `Email`, `Homepage`, `Url`, `SourceType`, `SourceMD5`, `SourceSHA1`) VALUES (@name, @description, @category, @version, @author, @email, @homepage, @uri, @sourcetype, @sourcemd5, @sourcesha1); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
 
-                                    db.ExecuteCMD(sql, dbDict);
+                                sigDB = db.ExecuteCMD(sql, dbDict);
+
+                                sourceId = Convert.ToInt32(sigDB.Rows[0][0]);
 
                                 processGames = true;
                             }
@@ -121,21 +171,88 @@ namespace gaseous_server.SignatureIngestors.XML
                                     dbDict.Add("platform", Common.ReturnValueIfNull(gameObject.System, ""));
                                     dbDict.Add("systemvariant", Common.ReturnValueIfNull(gameObject.SystemVariant, ""));
                                     dbDict.Add("video", Common.ReturnValueIfNull(gameObject.Video, ""));
-                                        dbDict.Add("country", Common.ReturnValueIfNull(gameObject.Country, ""));
-                                        dbDict.Add("language", Common.ReturnValueIfNull(gameObject.Language, ""));
+
+                                    List<int> gameCountries = new List<int>();
+                                    if (
+                                        gameObject.Country != null &&
+                                        gameObject.Country != "Unknown"
+                                        )
+                                    {
+                                        string[] countries = gameObject.Country.Split(",");
+                                        foreach (string country in countries)
+                                        {
+                                            int countryId = -1;
+                                            countryId = Common.GetLookupByCode(Common.LookupTypes.Country, (string)Common.ReturnValueIfNull(country.Trim(), ""));
+                                            if (countryId == -1)
+                                            {
+                                                countryId = Common.GetLookupByValue(Common.LookupTypes.Country, (string)Common.ReturnValueIfNull(country.Trim(), ""));
+
+                                                if (countryId == -1)
+                                                {
+                                                    Logging.Log(Logging.LogType.Warning, "Signature Ingest", "Unable to locate country id for " + country.Trim());
+                                                    sql = "INSERT INTO Country (`Code`, `Value`) VALUES (@code, @name); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                                    Dictionary<string, object> countryDict = new Dictionary<string, object>{
+                                                        { "code", country.Trim() },
+                                                        { "name", country.Trim() }
+                                                    };
+                                                    countryId = int.Parse(db.ExecuteCMD(sql, countryDict).Rows[0][0].ToString());
+                                                }
+                                            }
+
+                                            if (countryId > 0)
+                                            {
+                                                gameCountries.Add(countryId);
+                                            }
+                                        }
+                                    }
+
+                                    List<int> gameLanguages = new List<int>();
+                                    if (
+                                        gameObject.Language != null &&
+                                        gameObject.Language != "nolang"
+                                        )
+                                    {
+                                        string[] languages = gameObject.Language.Split(",");
+                                        foreach (string language in languages)
+                                        {
+                                            int languageId = -1;
+                                            languageId = Common.GetLookupByCode(Common.LookupTypes.Language, (string)Common.ReturnValueIfNull(language.Trim(), ""));
+                                            if (languageId == -1)
+                                            {
+                                                languageId = Common.GetLookupByValue(Common.LookupTypes.Language, (string)Common.ReturnValueIfNull(language.Trim(), ""));
+
+                                                if (languageId == -1)
+                                                {
+                                                    Logging.Log(Logging.LogType.Warning, "Signature Ingest", "Unable to locate language id for " + language.Trim());
+                                                    sql = "INSERT INTO Language (`Code`, `Value`) VALUES (@code, @name); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                                    Dictionary<string, object> langDict = new Dictionary<string, object>{
+                                                        { "code", language.Trim() },
+                                                        { "name", language.Trim() }
+                                                    };
+                                                    languageId = int.Parse(db.ExecuteCMD(sql, langDict).Rows[0][0].ToString());
+                                                }
+                                            }
+
+                                            if (languageId > 0)
+                                            {
+                                                gameLanguages.Add(languageId);
+                                            }
+                                        }
+                                    }
+
                                     dbDict.Add("copyright", Common.ReturnValueIfNull(gameObject.Copyright, ""));
 
                                     // store platform
                                     int gameSystem = 0;
                                     if (gameObject.System != null)
                                     {
-                                            sql = "SELECT Id FROM Signatures_Platforms WHERE Platform=@platform";
+                                        sql = "SELECT `Id` FROM Signatures_Platforms WHERE `Platform`=@platform";
 
                                         sigDB = db.ExecuteCMD(sql, dbDict);
                                         if (sigDB.Rows.Count == 0)
                                         {
                                             // entry not present, insert it
-                                                sql = "INSERT INTO Signatures_Platforms (Platform) VALUES (@platform); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                            sql = "INSERT INTO Signatures_Platforms (`Platform`) VALUES (@platform); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                                             sigDB = db.ExecuteCMD(sql, dbDict);
 
                                             gameSystem = Convert.ToInt32(sigDB.Rows[0][0]);
@@ -151,13 +268,13 @@ namespace gaseous_server.SignatureIngestors.XML
                                     int gamePublisher = 0;
                                     if (gameObject.Publisher != null)
                                     {
-                                            sql = "SELECT * FROM Signatures_Publishers WHERE Publisher=@publisher";
+                                        sql = "SELECT * FROM Signatures_Publishers WHERE `Publisher`=@publisher";
 
                                         sigDB = db.ExecuteCMD(sql, dbDict);
                                         if (sigDB.Rows.Count == 0)
                                         {
                                             // entry not present, insert it
-                                                sql = "INSERT INTO Signatures_Publishers (Publisher) VALUES (@publisher); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                            sql = "INSERT INTO Signatures_Publishers (`Publisher`) VALUES (@publisher); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                                             sigDB = db.ExecuteCMD(sql, dbDict);
                                             gamePublisher = Convert.ToInt32(sigDB.Rows[0][0]);
                                         }
@@ -169,16 +286,16 @@ namespace gaseous_server.SignatureIngestors.XML
                                     dbDict.Add("publisherid", gamePublisher);
 
                                     // store game
-                                        int gameId = 0;
-                                        sql = "SELECT * FROM Signatures_Games WHERE Name=@name AND Year=@year AND Publisherid=@publisher AND Systemid=@systemid AND Country=@country AND Language=@language";
+                                    long gameId = 0;
+                                    sql = "SELECT * FROM Signatures_Games WHERE `Name`=@name AND `Year`=@year AND `PublisherId`=@publisherid AND `SystemId`=@systemid";
 
                                     sigDB = db.ExecuteCMD(sql, dbDict);
                                     if (sigDB.Rows.Count == 0)
                                     {
                                         // entry not present, insert it
                                         sql = "INSERT INTO Signatures_Games " +
-                                                "(Name, Description, Year, PublisherId, Demo, SystemId, SystemVariant, Video, Country, Language, Copyright) VALUES " +
-                                                "(@name, @description, @year, @publisherid, @demo, @systemid, @systemvariant, @video, @country, @language, @copyright); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                            "(`Name`, `Description`, `Year`, `PublisherId`, `Demo`, `SystemId`, `SystemVariant`, `Video`, `Copyright`) VALUES " +
+                                            "(@name, @description, @year, @publisherid, @demo, @systemid, @systemvariant, @video, @copyright); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                                         sigDB = db.ExecuteCMD(sql, dbDict);
 
                                         gameId = Convert.ToInt32(sigDB.Rows[0][0]);
@@ -188,13 +305,57 @@ namespace gaseous_server.SignatureIngestors.XML
                                         gameId = (int)sigDB.Rows[0][0];
                                     }
 
+                                    // insert countries
+                                    foreach (int gameCountry in gameCountries)
+                                    {
+                                        try
+                                        {
+                                            sql = "SELECT * FROM Signatures_Games_Countries WHERE GameId = @gameid AND CountryId = @Countryid";
+                                            Dictionary<string, object> countryDict = new Dictionary<string, object>{
+                                                { "gameid", gameId },
+                                                { "Countryid", gameCountry }
+                                            };
+                                            if (db.ExecuteCMD(sql, countryDict).Rows.Count == 0)
+                                            {
+                                                sql = "INSERT INTO Signatures_Games_Countries (GameId, CountryId) VALUES (@gameid, @Countryid)";
+                                                db.ExecuteCMD(sql, countryDict);
+                                            }
+                                        }
+                                        catch
+                                        {
+                                            Console.WriteLine("Game id: " + gameId + " with Country " + gameCountry);
+                                        }
+                                    }
+
+                                    // insert languages
+                                    foreach (int gameLanguage in gameLanguages)
+                                    {
+                                        try
+                                        {
+                                            sql = "SELECT * FROM Signatures_Games_Languages WHERE GameId = @gameid AND LanguageId = @languageid";
+                                            Dictionary<string, object> langDict = new Dictionary<string, object>{
+                                                { "gameid", gameId },
+                                                { "languageid", gameLanguage }
+                                            };
+                                            if (db.ExecuteCMD(sql, langDict).Rows.Count == 0)
+                                            {
+                                                sql = "INSERT INTO Signatures_Games_Languages (GameId, LanguageId) VALUES (@gameid, @languageid)";
+                                                db.ExecuteCMD(sql, langDict);
+                                            }
+                                        }
+                                        catch
+                                        {
+                                            Console.WriteLine("Game id: " + gameId + " with language " + gameLanguage);
+                                        }
+                                    }
+
                                     // store rom
                                     foreach (RomSignatureObject.Game.Rom romObject in gameObject.Roms)
                                     {
                                         if (romObject.Md5 != null || romObject.Sha1 != null)
                                         {
-                                                int romId = 0;
-                                                sql = "SELECT * FROM Signatures_Roms WHERE GameId=@gameid AND MD5=@md5";
+                                            long romId = 0;
+                                            sql = "SELECT * FROM Signatures_Roms WHERE `GameId`=@gameid AND (`MD5`=@md5 OR `SHA1`=@sha1)";
                                             dbDict = new Dictionary<string, object>();
                                             dbDict.Add("gameid", gameId);
                                             dbDict.Add("name", Common.ReturnValueIfNull(romObject.Name, ""));
@@ -212,12 +373,12 @@ namespace gaseous_server.SignatureIngestors.XML
                                                 }
                                                 else
                                                 {
-                                                        dbDict.Add("attributes", "[ ]");
+                                                    dbDict.Add("attributes", "");
                                                 }
                                             }
                                             else
                                             {
-                                                    dbDict.Add("attributes", "[ ]");
+                                                dbDict.Add("attributes", "");
                                             }
                                             dbDict.Add("romtype", (int)romObject.RomType);
                                             dbDict.Add("romtypemedia", Common.ReturnValueIfNull(romObject.RomTypeMedia, ""));
@@ -229,30 +390,51 @@ namespace gaseous_server.SignatureIngestors.XML
                                             if (sigDB.Rows.Count == 0)
                                             {
                                                 // entry not present, insert it
-                                                    sql = "INSERT INTO Signatures_Roms (GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, MetadataSource, IngestorVersion) VALUES (@gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @attributes, @romtype, @romtypemedia, @medialabel, @metadatasource, @ingestorversion); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                                                sql = "INSERT INTO Signatures_Roms (`GameId`, `Name`, `Size`, `CRC`, `MD5`, `SHA1`, `DevelopmentStatus`, `Attributes`, `RomType`, `RomTypeMedia`, `MediaLabel`, `MetadataSource`, `IngestorVersion`) VALUES (@gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @attributes, @romtype, @romtypemedia, @medialabel, @metadatasource, @ingestorversion); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                                                 sigDB = db.ExecuteCMD(sql, dbDict);
 
-
                                                 romId = Convert.ToInt32(sigDB.Rows[0][0]);
                                             }
                                             else
                                             {
                                                 romId = (int)sigDB.Rows[0][0];
                                             }
+
+                                            // map the rom to the source
+                                            sql = "SELECT * FROM Signatures_RomToSource WHERE SourceId=@sourceid AND RomId=@romid;";
+                                            dbDict.Add("romid", romId);
+                                            dbDict.Add("sourceId", sourceId);
+
+                                            sigDB = db.ExecuteCMD(sql, dbDict);
+                                            if (sigDB.Rows.Count == 0)
+                                            {
+                                                sql = "INSERT INTO Signatures_RomToSource (`SourceId`, `RomId`) VALUES (@sourceid, @romid);";
+                                                db.ExecuteCMD(sql, dbDict);
                                             }
                                         }
                                     }
                                 }
                             }
                         }
+
+                        File.Move(XMLFile, Path.Combine(ProcessedDirectory, Path.GetFileName(XMLFile)));
+                        if (DBFile != null)
+                        {
+                            File.Move(DBFile, Path.Combine(XMLDBProcessedDirectory, Path.GetFileName(DBFile)));
+                        }
+                    }
                     catch (Exception ex)
                     {
-                            Logging.Log(Logging.LogType.Warning, "Signature Ingestor - XML", "Invalid import file: " + XMLFile, ex);
+                        Logging.Log(Logging.LogType.Warning, "Signature Ingest", "Error ingesting " + XMLType.ToString() + " file: " + XMLFile, ex);
                     }
                 }
                 else
                 {
-                        Logging.Log(Logging.LogType.Debug, "Signature Ingestor - XML", "Rejecting already imported file: " + XMLFile);
+                    Logging.Log(Logging.LogType.Information, "Signature Ingest", "Rejecting already imported " + XMLType.ToString() + " file: " + XMLFile);
+                    File.Move(XMLFile, Path.Combine(ProcessedDirectory, Path.GetFileName(XMLFile)));
+                    if (DBFile != null)
+                    {
+                        File.Move(DBFile, Path.Combine(XMLDBProcessedDirectory, Path.GetFileName(DBFile)));
                     }
                 }
             }

gaseous-server/Classes/SignatureManagement.cs

@@ -1,5 +1,7 @@
 using System.Data;
+using gaseous_server.Models;
 using gaseous_signature_parser.models.RomSignatureObject;
+using static gaseous_server.Classes.Common;
 
 namespace gaseous_server.Classes
 {
@@ -10,7 +12,8 @@ namespace gaseous_server.Classes
             if (md5.Length > 0)
             {
                 return _GetSignature("Signatures_Roms.md5 = @searchstring", md5);
-            } else
+            }
+            else
             {
                 return _GetSignature("Signatures_Roms.sha1 = @searchstring", sha1);
             }
@@ -21,7 +24,8 @@ namespace gaseous_server.Classes
             if (TosecName.Length > 0)
             {
                 return _GetSignature("Signatures_Roms.name = @searchstring", TosecName);
-            } else
+            }
+            else
             {
                 return null;
             }
@@ -44,7 +48,7 @@ namespace gaseous_server.Classes
                 {
                     Game = new gaseous_server.Models.Signatures_Games.GameItem
                     {
-                        Id = (Int32)sigDbRow["Id"],
+                        Id = (long)(int)sigDbRow["Id"],
                         Name = (string)sigDbRow["Name"],
                         Description = (string)sigDbRow["Description"],
                         Year = (string)sigDbRow["Year"],
@@ -53,20 +57,20 @@ namespace gaseous_server.Classes
                         System = (string)sigDbRow["Platform"],
                         SystemVariant = (string)sigDbRow["SystemVariant"],
                         Video = (string)sigDbRow["Video"],
-                        Country = (string)sigDbRow["Country"],
-                        Language = (string)sigDbRow["Language"],
+                        Countries = new Dictionary<string, string>(GetLookup(LookupTypes.Country, (long)(int)sigDbRow["Id"])),
+                        Languages = new Dictionary<string, string>(GetLookup(LookupTypes.Language, (long)(int)sigDbRow["Id"])),
                         Copyright = (string)sigDbRow["Copyright"]
                     },
                     Rom = new gaseous_server.Models.Signatures_Games.RomItem
                     {
-                        Id = (Int32)sigDbRow["romid"],
+                        Id = (long)(int)sigDbRow["romid"],
                         Name = (string)sigDbRow["romname"],
                         Size = (Int64)sigDbRow["Size"],
                         Crc = (string)sigDbRow["CRC"],
                         Md5 = ((string)sigDbRow["MD5"]).ToLower(),
                         Sha1 = ((string)sigDbRow["SHA1"]).ToLower(),
                         DevelopmentStatus = (string)sigDbRow["DevelopmentStatus"],
-                        Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<List<KeyValuePair<string, object>>>((string)Common.ReturnValueIfNull(sigDbRow["Attributes"], "[]")),
+                        Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>((string)Common.ReturnValueIfNull(sigDbRow["Attributes"], "[]")),
                         RomType = (gaseous_server.Models.Signatures_Games.RomItem.RomTypes)(int)sigDbRow["RomType"],
                         RomTypeMedia = (string)sigDbRow["RomTypeMedia"],
                         MediaLabel = (string)sigDbRow["MediaLabel"],
@@ -77,5 +81,77 @@ namespace gaseous_server.Classes
             }
             return GamesList;
         }
+
+        public List<Signatures_Sources> GetSources()
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM Signatures_Sources ORDER BY `SourceType`, `Name`;";
+            DataTable sigDb = db.ExecuteCMD(sql);
+
+            List<Signatures_Sources> SourcesList = new List<Signatures_Sources>();
+
+            foreach (DataRow sigDbRow in sigDb.Rows)
+            {
+                Signatures_Sources sourceItem = new Signatures_Sources
+                {
+                    Id = (int)sigDbRow["Id"],
+                    Name = (string)sigDbRow["Name"],
+                    Description = (string)sigDbRow["Description"],
+                    URL = (string)sigDbRow["URL"],
+                    Category = (string)sigDbRow["Category"],
+                    Version = (string)sigDbRow["Version"],
+                    Author = (string)sigDbRow["Author"],
+                    Email = (string)sigDbRow["Email"],
+                    Homepage = (string)sigDbRow["Homepage"],
+                    SourceType = (gaseous_signature_parser.parser.SignatureParser)Enum.Parse(typeof(gaseous_signature_parser.parser.SignatureParser), sigDbRow["SourceType"].ToString()),
+                    MD5 = (string)sigDbRow["SourceMD5"],
+                    SHA1 = (string)sigDbRow["SourceSHA1"]
+                };
+                SourcesList.Add(sourceItem);
+            }
+            return SourcesList;
+        }
+
+        public void DeleteSource(int sourceId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM Signatures_Sources WHERE Id = @sourceId;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "sourceId", sourceId }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public Dictionary<string, string> GetLookup(LookupTypes LookupType, long GameId)
+        {
+            string tableName = "";
+            switch (LookupType)
+            {
+                case LookupTypes.Country:
+                    tableName = "Countries";
+                    break;
+
+                case LookupTypes.Language:
+                    tableName = "Languages";
+                    break;
+
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT " + LookupType.ToString() + ".Code, " + LookupType.ToString() + ".Value FROM Signatures_Games_" + tableName + " JOIN " + LookupType.ToString() + " ON Signatures_Games_" + tableName + "." + LookupType.ToString() + "Id = " + LookupType.ToString() + ".Id WHERE Signatures_Games_" + tableName + ".GameId = @id;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "id", GameId }
+            };
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            Dictionary<string, string> returnDict = new Dictionary<string, string>();
+            foreach (DataRow row in data.Rows)
+            {
+                returnDict.Add((string)row["Code"], (string)row["Value"]);
+            }
+
+            return returnDict;
+        }
     }
 }

gaseous-server/Classes/Statistics.cs

@@ -5,29 +5,45 @@ namespace gaseous_server.Classes
 {
     public class Statistics
     {
-        public StatisticsModel RecordSession(Guid SessionId, long GameId, string UserId)
+        public StatisticsModel RecordSession(Guid SessionId, long GameId, long PlatformId, long RomId, bool IsMediaGroup, string UserId)
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql;
-            Dictionary<string, object> dbDict;
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId },
+                { "gameid", GameId },
+                { "platformid", PlatformId },
+                { "romid", RomId },
+                { "ismediagroup", IsMediaGroup }
+            };
+
+            // update last played rom id
+            sql = "INSERT INTO User_RecentPlayedRoms (UserId, GameId, PlatformId, RomId, IsMediaGroup) VALUES (@userid, @gameid, @platformid, @romid, @ismediagroup) ON DUPLICATE KEY UPDATE RomId = @romid, IsMediaGroup = @ismediagroup;";
+            db.ExecuteNonQuery(sql, dbDict);
+
+            // update sessions
 
             if (SessionId == Guid.Empty)
             {
                 // new session required
                 SessionId = Guid.NewGuid();
 
-                sql = "INSERT INTO UserTimeTracking (GameId, UserId, SessionId, SessionTime, SessionLength) VALUES (@gameid, @userid, @sessionid, @sessiontime, @sessionlength);";
+                sql = "INSERT INTO UserTimeTracking (GameId, UserId, SessionId, SessionTime, SessionLength, PlatformId, IsMediaGroup, RomId) VALUES (@gameid, @userid, @sessionid, @sessiontime, @sessionlength, @platformid, @ismediagroup, @romid);";
                 dbDict = new Dictionary<string, object>{
                     { "gameid", GameId },
                     { "userid", UserId },
                     { "sessionid", SessionId },
                     { "sessiontime", DateTime.UtcNow },
-                    { "sessionlength", 1 }
+                    { "sessionlength", 1 },
+                    { "platformid", PlatformId },
+                    { "ismediagroup", IsMediaGroup },
+                    { "romid", RomId }
                 };
 
                 db.ExecuteNonQuery(sql, dbDict);
 
-                return new StatisticsModel{
+                return new StatisticsModel
+                {
                     GameId = GameId,
                     SessionId = SessionId,
                     SessionStart = (DateTime)dbDict["sessiontime"],
@@ -50,7 +66,8 @@ namespace gaseous_server.Classes
                 sql = "SELECT * FROM UserTimeTracking WHERE GameId = @gameid AND UserId = @userid AND SessionId = @sessionid;";
                 DataTable data = db.ExecuteCMD(sql, dbDict);
 
-                return new StatisticsModel{
+                return new StatisticsModel
+                {
                     GameId = (long)data.Rows[0]["GameId"],
                     SessionId = Guid.Parse(data.Rows[0]["SessionId"].ToString()),
                     SessionStart = (DateTime)data.Rows[0]["SessionTime"],
@@ -87,7 +104,8 @@ namespace gaseous_server.Classes
                     sql = "SELECT * FROM UserTimeTracking WHERE GameId = @gameid AND UserId = @userid ORDER BY SessionTime DESC LIMIT 1;";
                     data = db.ExecuteCMD(sql, dbDict);
 
-                    return new StatisticsModel{
+                    return new StatisticsModel
+                    {
                         GameId = GameId,
                         SessionLength = TotalTime,
                         SessionStart = (DateTime)data.Rows[0]["SessionTime"]

gaseous-server/Classes/UserProfile.cs

@@ -0,0 +1,218 @@
+using System.Data;
+using gaseous_server.Classes.Metadata;
+using gaseous_server.Models;
+using HasheousClient.Models;
+
+namespace gaseous_server.Classes
+{
+    public class UserProfile
+    {
+        static readonly Dictionary<string, string> supportedImages = new Dictionary<string, string>{
+            { ".png", "image/png" },
+            { ".jpg", "image/jpeg" },
+            { ".jpeg", "image/jpeg" },
+            { ".gif", "image/gif" },
+            { ".bmp", "image/bmp" },
+            { ".svg", "image/svg+xml" }
+        };
+
+        public Models.UserProfile? GetUserProfile(string UserId)
+        {
+            // build the user profile object
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT Id, UserId, DisplayName, Quip, AvatarExtension, ProfileBackgroundExtension, UnstructuredData FROM UserProfiles WHERE Id = @userid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId }
+            };
+
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count == 0)
+            {
+                return null;
+            }
+
+            Models.UserProfile.ProfileImageItem? Avatar = null;
+            if (data.Rows[0]["AvatarExtension"] != DBNull.Value)
+            {
+                Avatar = new Models.UserProfile.ProfileImageItem
+                {
+                    MimeType = supportedImages[data.Rows[0]["AvatarExtension"].ToString()],
+                    Extension = data.Rows[0]["AvatarExtension"].ToString()
+                };
+            }
+
+            Models.UserProfile.ProfileImageItem? ProfileBackground = null;
+            if (data.Rows[0]["ProfileBackgroundExtension"] != DBNull.Value)
+            {
+                ProfileBackground = new Models.UserProfile.ProfileImageItem
+                {
+                    MimeType = supportedImages[data.Rows[0]["ProfileBackgroundExtension"].ToString()],
+                    Extension = data.Rows[0]["ProfileBackgroundExtension"].ToString()
+                };
+            }
+
+            // get now playing game - if available
+            Models.UserProfile.NowPlayingItem? NowPlaying = null;
+            sql = "SELECT * FROM `view_UserTimeTracking` WHERE UserId = @userid AND UTC_TIMESTAMP() BETWEEN SessionTime AND DATE_ADD(SessionEnd, INTERVAL 2 MINUTE) ORDER BY SessionEnd DESC LIMIT 1;";
+            dbDict = new Dictionary<string, object>{
+                { "userid", data.Rows[0]["UserId"].ToString() }
+            };
+            DataTable nowPlayingData = db.ExecuteCMD(sql, dbDict);
+            if (nowPlayingData.Rows.Count > 0)
+            {
+                try
+                {
+                    gaseous_server.Models.MetadataMap.MetadataMapItem metadataMap = Classes.MetadataManagement.GetMetadataMap((long)nowPlayingData.Rows[0]["GameId"]).PreferredMetadataMapItem;
+                    NowPlaying = new Models.UserProfile.NowPlayingItem
+                    {
+                        Game = Games.GetGame(metadataMap.SourceType, metadataMap.SourceId),
+                        Platform = Platforms.GetPlatform((long)nowPlayingData.Rows[0]["PlatformId"]),
+                        Duration = Convert.ToInt64(nowPlayingData.Rows[0]["SessionLength"])
+                    };
+                }
+                catch (Exception e)
+                {
+                    Console.WriteLine(e.Message);
+                }
+            }
+
+            // return the user profile object
+            return new Models.UserProfile
+            {
+                UserId = Guid.Parse(data.Rows[0]["Id"].ToString()),
+                DisplayName = data.Rows[0]["DisplayName"].ToString(),
+                Quip = data.Rows[0]["Quip"].ToString(),
+                Avatar = Avatar,
+                ProfileBackground = ProfileBackground,
+                NowPlaying = NowPlaying,
+                Data = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(data.Rows[0]["UnstructuredData"].ToString())
+            };
+        }
+
+        public void UpdateUserProfile(string InternalUserId, Models.UserProfile profile)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "UPDATE UserProfiles SET DisplayName = @displayname, Quip = @quip, UnstructuredData = @data WHERE UserId = @internalId AND Id = @userid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "displayname", profile.DisplayName },
+                { "quip", profile.Quip },
+                { "data", Newtonsoft.Json.JsonConvert.SerializeObject(profile.Data) },
+                { "userid", profile.UserId },
+                { "internalId", InternalUserId }
+            };
+
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public enum ImageType
+        {
+            Avatar,
+            Background
+        }
+
+        public void UpdateImage(ImageType imageType, string UserId, string InternalUserId, string Filename, byte[] bytes)
+        {
+            // check if it's a supported file type
+            if (!supportedImages.ContainsKey(Path.GetExtension(Filename).ToLower()))
+            {
+                throw new Exception("File type not supported");
+            }
+
+            string ByteFieldName;
+            string ExtensionFieldName;
+            switch (imageType)
+            {
+                case ImageType.Avatar:
+                    ByteFieldName = "Avatar";
+                    ExtensionFieldName = "AvatarExtension";
+                    break;
+                case ImageType.Background:
+                    ByteFieldName = "ProfileBackground";
+                    ExtensionFieldName = "ProfileBackgroundExtension";
+                    break;
+                default:
+                    throw new Exception("Invalid image type");
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = String.Format("UPDATE UserProfiles SET {0} = @content, {1} = @extension WHERE Id = @userid AND UserId = @internaluserid;", ByteFieldName, ExtensionFieldName);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "content", bytes },
+                { "extension", Path.GetExtension(Filename) },
+                { "userid", UserId },
+                { "internaluserid", InternalUserId }
+            };
+
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public Models.ImageItem? GetImage(ImageType imageType, string UserId)
+        {
+            string ByteFieldName;
+            string ExtensionFieldName;
+            switch (imageType)
+            {
+                case ImageType.Avatar:
+                    ByteFieldName = "Avatar";
+                    ExtensionFieldName = "AvatarExtension";
+                    break;
+                case ImageType.Background:
+                    ByteFieldName = "ProfileBackground";
+                    ExtensionFieldName = "ProfileBackgroundExtension";
+                    break;
+                default:
+                    throw new Exception("Invalid image type");
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = String.Format("SELECT {0}, {1} FROM UserProfiles WHERE Id = @userid;", ByteFieldName, ExtensionFieldName);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId }
+            };
+
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count == 0)
+            {
+                return null;
+            }
+
+            Models.ImageItem? image = new Models.ImageItem
+            {
+                content = data.Rows[0][ByteFieldName] as byte[],
+                mimeType = supportedImages[data.Rows[0][ExtensionFieldName] as string],
+                extension = data.Rows[0][ExtensionFieldName] as string
+            };
+
+            return image;
+        }
+
+        public void DeleteImage(ImageType imageType, string UserId)
+        {
+            string ByteFieldName;
+            string ExtensionFieldName;
+            switch (imageType)
+            {
+                case ImageType.Avatar:
+                    ByteFieldName = "Avatar";
+                    ExtensionFieldName = "AvatarExtension";
+                    break;
+                case ImageType.Background:
+                    ByteFieldName = "ProfileBackground";
+                    ExtensionFieldName = "ProfileBackgroundExtension";
+                    break;
+                default:
+                    throw new Exception("Invalid image type");
+            }
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = String.Format("UPDATE UserProfiles SET {0} = NULL, {1} = NULL WHERE UserId = @userid;", ByteFieldName, ExtensionFieldName);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "userid", UserId }
+            };
+
+            db.ExecuteCMD(sql, dbDict);
+        }
+    }
+}

gaseous-server/Controllers/V1.0/AccountController.cs

@@ -99,7 +99,7 @@ namespace gaseous_server.Controllers
             profile.Roles = new List<string>(await _userManager.GetRolesAsync(user));
             profile.SecurityProfile = user.SecurityProfile;
             profile.UserPreferences = user.UserPreferences;
-            profile.Avatar = user.Avatar;
+            profile.ProfileId = user.ProfileId;
             profile.Roles.Sort();
 
             return Ok(profile);
@@ -188,7 +188,7 @@ namespace gaseous_server.Controllers
                 user.LockoutEnabled = rawUser.LockoutEnabled;
                 user.LockoutEnd = rawUser.LockoutEnd;
                 user.SecurityProfile = rawUser.SecurityProfile;
-                user.Avatar = rawUser.Avatar;
+                user.ProfileId = rawUser.ProfileId;
 
                 // get roles
                 ApplicationUser? aUser = await _userManager.FindByIdAsync(rawUser.Id);
@@ -220,6 +220,10 @@ namespace gaseous_server.Controllers
                     Email = model.Email,
                     NormalizedEmail = model.Email.ToUpper()
                 };
+                if (await _userManager.FindByEmailAsync(model.Email) != null)
+                {
+                    return NotFound("User already exists");
+                }
                 var result = await _userManager.CreateAsync(user, model.Password);
                 if (result.Succeeded)
                 {
@@ -241,6 +245,23 @@ namespace gaseous_server.Controllers
             }
         }
 
+        [HttpGet]
+        [Route("Users/Test")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> TestUserExists(string Email)
+        {
+            ApplicationUser? rawUser = await _userManager.FindByEmailAsync(Email);
+
+            if (rawUser != null)
+            {
+                return Ok(true);
+            }
+            else
+            {
+                return Ok(false);
+            }
+        }
+
         [HttpGet]
         [Route("Users/{UserId}")]
         [Authorize(Roles = "Admin")]
@@ -256,6 +277,7 @@ namespace gaseous_server.Controllers
                 user.LockoutEnabled = rawUser.LockoutEnabled;
                 user.LockoutEnd = rawUser.LockoutEnd;
                 user.SecurityProfile = rawUser.SecurityProfile;
+                user.ProfileId = rawUser.ProfileId;
 
                 // get roles
                 IList<string> aUserRoles = await _userManager.GetRolesAsync(rawUser);

gaseous-server/Controllers/V1.0/BiosController.cs

@@ -7,6 +7,11 @@ using gaseous_server.Classes;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Asp.Versioning;
+using Authentication;
+using Microsoft.AspNetCore.Identity;
+using gaseous_server.Models;
+using gaseous_server.Classes.Metadata;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Controllers
 {
@@ -17,6 +22,15 @@ namespace gaseous_server.Controllers
     [Authorize]
     public class BiosController : Controller
     {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+
+        public BiosController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager)
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+        }
+
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
@@ -43,24 +57,55 @@ namespace gaseous_server.Controllers
         [MapToApiVersion("1.1")]
         [HttpHead]
         [Route("zip/{PlatformId}")]
+        [Route("zip/{PlatformId}/{GameId}")]
         [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetBiosCompressed(long PlatformId)
+        public async Task<ActionResult> GetBiosCompressedAsync(long PlatformId, long GameId = -1, bool filtered = false)
         {
             try
             {
-                IGDB.Models.Platform platform = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+                Platform platform = Platforms.GetPlatform(PlatformId);
+                PlatformMapping.PlatformMapItem platformMap = PlatformMapping.GetPlatformMap(PlatformId);
 
-                string biosPath = Path.Combine(Config.LibraryConfiguration.LibraryBIOSDirectory, platform.Slug);
+                List<string> biosHashes = new List<string>();
 
+                if (GameId == -1 || filtered == false)
+                {
+                    // get all bios files for selected platform
+                    biosHashes.AddRange(platformMap.EnabledBIOSHashes);
+                }
+                else
+                {
+                    // get user platform map
+                    var user = await _userManager.GetUserAsync(User);
+
+                    PlatformMapping platformMapping = new PlatformMapping();
+                    PlatformMapping.PlatformMapItem userPlatformMap = platformMapping.GetUserPlatformMap(user.Id, PlatformId, GameId);
+
+                    biosHashes.AddRange(userPlatformMap.EnabledBIOSHashes);
+                }
+
+                // build zip file
                 string tempFile = Path.GetTempFileName();
 
                 using (FileStream zipFile = System.IO.File.Create(tempFile))
                 using (var zipArchive = new ZipArchive(zipFile, ZipArchiveMode.Create))
                 {
-                    foreach (string file in Directory.GetFiles(biosPath))
+                    foreach (string hash in biosHashes)
                     {
-                        zipArchive.CreateEntryFromFile(file, Path.GetFileName(file));
+                        // get the bios data for the hash
+                        foreach (PlatformMapping.PlatformMapItem.EmulatorBiosItem bios in platformMap.Bios)
+                        {
+                            if (bios.hash == hash)
+                            {
+                                // add the bios file to the zip
+                                string biosFilePath = Path.Combine(Config.LibraryConfiguration.LibraryFirmwareDirectory, hash + ".bios");
+                                if (System.IO.File.Exists(biosFilePath))
+                                {
+                                    zipArchive.CreateEntryFromFile(biosFilePath, bios.filename);
+                                }
+                            }
+                        }
                     }
                 }
 

gaseous-server/Controllers/V1.0/LibraryController.cs

@@ -86,5 +86,24 @@ namespace gaseous_server.Controllers
                 return NotFound(exLNF.ToString());
             }
         }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost("{LibraryId}/Scan")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public ActionResult ScanLibrary(int LibraryId)
+        {
+            try
+            {
+                GameLibrary.ScanLibrary(LibraryId);
+                return Ok();
+            }
+            catch (GameLibrary.LibraryNotFound exLNF)
+            {
+                return NotFound(exLNF.ToString());
+            }
+        }
     }
 }

gaseous-server/Controllers/V1.0/PlatformMapsController.cs

@@ -149,35 +149,6 @@ namespace gaseous_server.Controllers
             return Ok(new { count = files.Count, size });
         }
 
-        // [MapToApiVersion("1.0")]
-        [MapToApiVersion("1.1")]
-        [HttpPost]
-        // [Route("{PlatformId}")]
-        // [ProducesResponseType(typeof(PlatformMapping.PlatformMapItem), StatusCodes.Status200OK)]
-        // [ProducesResponseType(StatusCodes.Status404NotFound)]
-        // [ProducesResponseType(StatusCodes.Status409Conflict)]
-        // public ActionResult NewPlatformMap(long PlatformId, PlatformMapping.PlatformMapItem Map)
-        // {
-        //     try
-        //     {
-        //         PlatformMapping.PlatformMapItem platformMapItem = PlatformMapping.GetPlatformMap(PlatformId);
-
-        //         if (platformMapItem != null)
-        //         {
-        //             return Conflict();
-        //         }
-        //         else
-        //         {
-        //             PlatformMapping.WritePlatformMap(Map, false, false);
-        //             return Ok(PlatformMapping.GetPlatformMap(PlatformId));
-        //         }
-        //     }
-        //     catch
-        //     {
-        //         return NotFound();
-        //     }
-        // }
-
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpPatch]

gaseous-server/Controllers/V1.0/PlatformsController.cs

@@ -8,12 +8,12 @@ using System.Threading.Tasks;
 using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
 using gaseous_server.Models;
-using IGDB.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.CodeAnalysis.Scripting;
 using Asp.Versioning;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Controllers
 {
@@ -37,7 +37,7 @@ namespace gaseous_server.Controllers
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
-            string sql = "SELECT * FROM Platform WHERE Id IN (SELECT DISTINCT PlatformId FROM Games_Roms) ORDER BY `Name` ASC;";
+            string sql = "SELECT * FROM Platform WHERE Id IN (SELECT DISTINCT PlatformId FROM view_Games_Roms) ORDER BY `Name` ASC;";
 
             List<Platform> RetVal = new List<Platform>();
 
@@ -60,7 +60,7 @@ namespace gaseous_server.Controllers
         {
             try
             {
-                IGDB.Models.Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+                Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
 
                 if (platformObject != null)
                 {
@@ -77,59 +77,166 @@ namespace gaseous_server.Controllers
             }
         }
 
-        [MapToApiVersion("1.0")]
-        [MapToApiVersion("1.1")]
-        [HttpGet]
-        [Route("{PlatformId}/platformlogo")]
-        [ProducesResponseType(typeof(PlatformLogo), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult PlatformLogo(long PlatformId)
-        {
-            try
-            {
-                IGDB.Models.Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
-                if (platformObject != null)
-                {
-                    IGDB.Models.PlatformLogo logoObject = PlatformLogos.GetPlatformLogo(platformObject.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject));
-                    if (logoObject != null)
-                    {
-                        return Ok(logoObject);
-                    }
-                    else
-                    {
-                        return NotFound();
-                    }
-                }
-                else
-                {
-                    return NotFound();
-                }
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
+        // [MapToApiVersion("1.0")]
+        // [MapToApiVersion("1.1")]
+        // [HttpGet]
+        // [Route("{PlatformId}/platformlogo")]
+        // [ProducesResponseType(typeof(PlatformLogo), StatusCodes.Status200OK)]
+        // [ProducesResponseType(StatusCodes.Status404NotFound)]
+        // public ActionResult PlatformLogo(long PlatformId)
+        // {
+        //     try
+        //     {
+        //         Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+        //         if (platformObject != null)
+        //         {
+        //             PlatformLogo logoObjectParent = (PlatformLogo)platformObject.PlatformLogo;
+        //             PlatformLogo logoObject = PlatformLogos.GetPlatformLogo(logoObjectParent.Id);
+        //             if (logoObject != null)
+        //             {
+        //                 return Ok(logoObject);
+        //             }
+        //             else
+        //             {
+        //                 return NotFound();
+        //             }
+        //         }
+        //         else
+        //         {
+        //             return NotFound();
+        //         }
+        //     }
+        //     catch
+        //     {
+        //         return NotFound();
+        //     }
+        // }
 
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
-        [Route("{PlatformId}/platformlogo/image")]
+        [Route("{PlatformId}/platformlogo/{size}/")]
+        [Route("{PlatformId}/platformlogo/{size}/logo.png")]
         [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult PlatformLogoImage(long PlatformId)
+        public async Task<ActionResult> GameImage(long PlatformId, Communications.IGDBAPI_ImageSize size)
         {
             try
             {
-                IGDB.Models.Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId);
+                HasheousClient.Models.MetadataSources metadataSources = HasheousClient.Models.MetadataSources.None;
 
-                string logoFilePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject), "Logo_Medium.png");
-                if (System.IO.File.Exists(logoFilePath))
+                Platform platformObject = Classes.Metadata.Platforms.GetPlatform(PlatformId, metadataSources);
+                PlatformLogo? logoObject = null;
+
+                logoObject = PlatformLogos.GetPlatformLogo((long)platformObject.PlatformLogo, metadataSources);
+
+                if (logoObject == null)
                 {
-                    string filename = "Logo.png";
-                    string filepath = logoFilePath;
-                    byte[] filedata = System.IO.File.ReadAllBytes(filepath);
-                    string contentType = "image/png";
+                    // getting the logo failed, so we'll try a platform variant if available
+                    if (platformObject.Versions != null)
+                    {
+                        if (platformObject.Versions.Count > 0)
+                        {
+                            PlatformVersion platformVersion = Classes.Metadata.PlatformVersions.GetPlatformVersion(metadataSources, (long)platformObject.Versions[0]);
+                            logoObject = PlatformLogos.GetPlatformLogo((long)platformVersion.PlatformLogo);
+                        }
+                        else
+                        {
+                            return GetDummyImage();
+                        }
+                    }
+                    else
+                    {
+                        return GetDummyImage();
+                    }
+                }
+
+                string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject), metadataSources.ToString());
+                string imagePath = Path.Combine(basePath, size.ToString(), logoObject.ImageId);
+
+                if (!System.IO.File.Exists(imagePath))
+                {
+                    Communications comms = new Communications();
+                    Task<string> ImgFetch = comms.GetSpecificImageFromServer(metadataSources, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject)), logoObject.ImageId, size, new List<Communications.IGDBAPI_ImageSize> { Communications.IGDBAPI_ImageSize.cover_big, Communications.IGDBAPI_ImageSize.original });
+
+                    imagePath = ImgFetch.Result;
+                }
+
+                if (!System.IO.File.Exists(imagePath))
+                {
+                    Communications comms = new Communications();
+                    Task<string> ImgFetch = comms.GetSpecificImageFromServer(metadataSources, basePath, logoObject.ImageId, size, new List<Communications.IGDBAPI_ImageSize> { Communications.IGDBAPI_ImageSize.cover_big, Communications.IGDBAPI_ImageSize.original });
+
+                    imagePath = ImgFetch.Result;
+                }
+
+                if (System.IO.File.Exists(imagePath))
+                {
+                    // get image info
+                    var info = new ImageMagick.MagickImageInfo(imagePath);
+                    string extension = ".jpg";
+                    string mimeType = "image/jpg";
+                    switch (info.Format)
+                    {
+                        case ImageMagick.MagickFormat.Jpeg:
+                            extension = ".jpg";
+                            mimeType = "image/jpg";
+                            break;
+
+                        case ImageMagick.MagickFormat.Png:
+                            extension = ".png";
+                            mimeType = "image/png";
+                            break;
+
+                        case ImageMagick.MagickFormat.Gif:
+                            extension = ".gif";
+                            mimeType = "image/gif";
+                            break;
+
+                        case ImageMagick.MagickFormat.Bmp:
+                            extension = ".bmp";
+                            mimeType = "image/bmp";
+                            break;
+
+                        case ImageMagick.MagickFormat.Tiff:
+                            extension = ".tiff";
+                            mimeType = "image/tiff";
+                            break;
+
+                        case ImageMagick.MagickFormat.Unknown:
+                            extension = ".jpg";
+                            mimeType = "image/jpg";
+                            break;
+
+                        case ImageMagick.MagickFormat.WebP:
+                            extension = ".webp";
+                            mimeType = "image/webp";
+                            break;
+
+                        case ImageMagick.MagickFormat.Heic:
+                            extension = ".heic";
+                            mimeType = "image/heic";
+                            break;
+
+                        case ImageMagick.MagickFormat.Heif:
+                            extension = ".heif";
+                            mimeType = "image/heif";
+                            break;
+
+                        case ImageMagick.MagickFormat.Svg:
+                            extension = ".svg";
+                            mimeType = "image/svg+xml";
+                            break;
+
+                        default:
+                            extension = ".jpg";
+                            mimeType = "image/jpg";
+                            break;
+                    }
+
+                    string filename = logoObject.ImageId + extension;
+                    string filepath = imagePath;
+                    string contentType = mimeType;
 
                     var cd = new System.Net.Mime.ContentDisposition
                     {
@@ -138,6 +245,16 @@ namespace gaseous_server.Controllers
                     };
 
                     Response.Headers.Add("Content-Disposition", cd.ToString());
+                    Response.Headers.Add("Cache-Control", "public, max-age=604800");
+
+                    byte[] filedata = null;
+                    using (FileStream fs = System.IO.File.OpenRead(filepath))
+                    {
+                        using (BinaryReader binaryReader = new BinaryReader(fs))
+                        {
+                            filedata = binaryReader.ReadBytes((int)fs.Length);
+                        }
+                    }
 
                     return File(filedata, contentType);
                 }
@@ -151,6 +268,50 @@ namespace gaseous_server.Controllers
                 return NotFound();
             }
         }
+
+        private ActionResult GetDummyImage()
+        {
+            // return resource named DefaultPlatformLogo.svg
+            var assembly = Assembly.GetExecutingAssembly();
+            string resourceName = "gaseous_server.Support.DefaultPlatformLogo.svg";
+            string[] resources = Assembly.GetExecutingAssembly().GetManifestResourceNames();
+            if (resources.Contains(resourceName))
+            {
+                string svgData = "";
+                using (Stream stream = assembly.GetManifestResourceStream(resourceName))
+                using (StreamReader reader = new StreamReader(stream))
+                {
+                    svgData = reader.ReadToEnd();
+                }
+
+                var cd = new System.Net.Mime.ContentDisposition
+                {
+                    FileName = "DefaultPlatformLogo.svg",
+                    Inline = true,
+                };
+
+                Response.Headers.Add("Content-Disposition", cd.ToString());
+                Response.Headers.Add("Cache-Control", "public, max-age=604800");
+
+                byte[] filedata = null;
+                using (MemoryStream ms = new MemoryStream())
+                {
+                    using (StreamWriter writer = new StreamWriter(ms))
+                    {
+                        writer.Write(svgData);
+                        writer.Flush();
+                        ms.Position = 0;
+                        filedata = ms.ToArray();
+                    }
+                }
+
+                return File(filedata, "image/svg+xml");
+            }
+            else
+            {
+                return NotFound();
+            }
+        }
     }
 }
 

gaseous-server/Controllers/V1.0/RomsController.cs

@@ -8,13 +8,13 @@ using System.Reflection;
 using System.Threading.Tasks;
 using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
-using IGDB.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.CodeAnalysis.Scripting;
 using static gaseous_server.Classes.Metadata.AgeRatings;
 using Asp.Versioning;
+using HasheousClient.Models.Metadata.IGDB;
 
 namespace gaseous_server.Controllers
 {
@@ -31,55 +31,59 @@ namespace gaseous_server.Controllers
         [Authorize(Roles = "Admin,Gamer")]
         [ProducesResponseType(typeof(List<IFormFile>), StatusCodes.Status200OK)]
         [RequestSizeLimit(long.MaxValue)]
+        [Consumes("multipart/form-data")]
         [DisableRequestSizeLimit, RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue, ValueLengthLimit = int.MaxValue)]
-        public async Task<IActionResult> UploadRom(List<IFormFile> files, long? OverridePlatformId = null)
+        public async Task<IActionResult> UploadRom(IFormFile file, long? OverridePlatformId = null)
         {
             Guid sessionid = Guid.NewGuid();
 
             string workPath = Path.Combine(Config.LibraryConfiguration.LibraryUploadDirectory, sessionid.ToString());
 
-            long size = files.Sum(f => f.Length);
-
-            List<Dictionary<string, object>> UploadedFiles = new List<Dictionary<string, object>>();
-
-            foreach (IFormFile formFile in files)
-            {
-                if (formFile.Length > 0)
+            if (file.Length > 0)
             {
                 Guid FileId = Guid.NewGuid();
 
-                    string filePath = Path.Combine(workPath, Path.GetFileName(formFile.FileName));
+                string filePath = Path.Combine(workPath, Path.GetFileName(file.FileName));
 
                 if (!Directory.Exists(workPath))
                 {
                     Directory.CreateDirectory(workPath);
                 }
 
+                Dictionary<string, object> UploadedFile = new Dictionary<string, object>();
+
                 using (var stream = System.IO.File.Create(filePath))
                 {
-                        await formFile.CopyToAsync(stream);
+                    await file.CopyToAsync(stream);
 
-                        Dictionary<string, object> UploadedFile = new Dictionary<string, object>();
                     UploadedFile.Add("id", FileId.ToString());
-                        UploadedFile.Add("originalname", Path.GetFileName(formFile.FileName));
+                    UploadedFile.Add("originalname", Path.GetFileName(file.FileName));
                     UploadedFile.Add("fullpath", filePath);
-                        UploadedFiles.Add(UploadedFile);
-                    }
-                }
                 }
 
                 // get override platform if specified
-            IGDB.Models.Platform? OverridePlatform = null;
+                Platform? OverridePlatform = null;
                 if (OverridePlatformId != null)
                 {
                     OverridePlatform = Platforms.GetPlatform((long)OverridePlatformId);
                 }
 
-            // Process uploaded files
-            foreach (Dictionary<string, object> UploadedFile in UploadedFiles)
-            {
+                // Process uploaded file
                 Classes.ImportGame uploadImport = new ImportGame();
-                uploadImport.ImportGameFile((string)UploadedFile["fullpath"], OverridePlatform);
+                Dictionary<string, object> RetVal = uploadImport.ImportGameFile((string)UploadedFile["fullpath"], OverridePlatform);
+                switch (RetVal["type"])
+                {
+                    case "rom":
+                        if (RetVal["status"] == "imported")
+                        {
+                            gaseous_server.Models.Game? game = (gaseous_server.Models.Game)RetVal["game"];
+                            if (game == null || game.Id == null)
+                            {
+                                RetVal["game"] = Games.GetGame(HasheousClient.Models.MetadataSources.IGDB, 0);
+                            }
+                        }
+                        break;
+
                 }
 
                 if (Directory.Exists(workPath))
@@ -87,7 +91,10 @@ namespace gaseous_server.Controllers
                     Directory.Delete(workPath, true);
                 }
 
-            return Ok(new { count = files.Count, size });
+                return Ok(RetVal);
+            }
+
+            return Ok();
         }
     }
 }

gaseous-server/Controllers/V1.0/SearchController.cs

@@ -6,8 +6,7 @@ using System.Threading.Tasks;
 using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
 using gaseous_server.Models;
-using IGDB;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using NuGet.Common;
@@ -36,76 +35,75 @@ namespace gaseous_server.Controllers
 
         private static async Task<List<Platform>> _SearchForPlatform(string SearchString)
         {
-            string searchBody = "";
-            string searchFields = "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites; ";
-            searchBody += "where name ~ *\"" + SearchString + "\"*;";
+            // search the database for the requested platforms
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string query = "SELECT `Id` FROM Platform WHERE `Name` LIKE '%" + SearchString + "%';";
+            DataTable data = db.ExecuteCMD(query);
 
-            List<Platform>? searchCache = Communications.GetSearchCache<List<Platform>>(searchFields, searchBody);
-
-            if (searchCache == null)
+            List<Platform> platforms = new List<Platform>();
+            foreach (DataRow row in data.Rows)
             {
-                // cache miss
-                // get Platform metadata from data source
-                Communications comms = new Communications();
-                var results = await comms.APIComm<Platform>(IGDBClient.Endpoints.Platforms, searchFields, searchBody);
+                Platform platform = Platforms.GetPlatform((long)row["Id"]);
 
-                Communications.SetSearchCache<List<Platform>>(searchFields, searchBody, results.ToList());
+                platforms.Add(platform);
+            }
 
-                return results.ToList();
-            }
-            else
-            {
-                return searchCache;
-            }
+            return platforms;
         }
 
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
         [Route("Game")]
-        [ProducesResponseType(typeof(List<GaseousGame>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(List<gaseous_server.Models.Game>), StatusCodes.Status200OK)]
         public async Task<ActionResult> SearchGame(long PlatformId, string SearchString)
         {
-            List<GaseousGame> RetVal = await _SearchForGame(PlatformId, SearchString);
+            List<gaseous_server.Models.Game> RetVal = await _SearchForGame(PlatformId, SearchString);
             return Ok(RetVal);
         }
 
-        private static async Task<List<GaseousGame>> _SearchForGame(long PlatformId, string SearchString)
+        private static async Task<List<gaseous_server.Models.Game>> _SearchForGame(long PlatformId, string SearchString)
+        {
+            switch (Config.MetadataConfiguration.DefaultMetadataSource)
+            {
+                case HasheousClient.Models.MetadataSources.IGDB:
+                    if (Config.IGDB.UseHasheousProxy == false)
                     {
                         string searchBody = "";
-            string searchFields = "fields cover,first_release_date,name,platforms,slug; ";
+                        string searchFields = "fields *; ";
                         searchBody += "search \"" + SearchString + "\";";
                         searchBody += "where platforms = (" + PlatformId + ");";
+                        searchBody += "limit 100;";
 
-            List<GaseousGame>? searchCache = Communications.GetSearchCache<List<GaseousGame>>(searchFields, searchBody);
+                        List<gaseous_server.Models.Game>? searchCache = Communications.GetSearchCache<List<gaseous_server.Models.Game>>(searchFields, searchBody);
 
                         if (searchCache == null)
                         {
                             // cache miss
                             // get Game metadata from data source
                             Communications comms = new Communications();
-                var results = await comms.APIComm<Game>(IGDBClient.Endpoints.Games, searchFields, searchBody);
+                            var results = await comms.APIComm<gaseous_server.Models.Game>("Game", searchFields, searchBody);
 
-                List<GaseousGame> games = new List<GaseousGame>();
-                foreach (Game game in results.ToList())
+                            List<gaseous_server.Models.Game> games = new List<gaseous_server.Models.Game>();
+                            foreach (gaseous_server.Models.Game game in results.ToList())
                             {
-                    Storage.CacheStatus cacheStatus = Storage.GetCacheStatus("Game", (long)game.Id);
+                                Storage.CacheStatus cacheStatus = Storage.GetCacheStatus(HasheousClient.Models.MetadataSources.IGDB, "Game", (long)game.Id);
                                 switch (cacheStatus)
                                 {
                                     case Storage.CacheStatus.NotPresent:
-                            Storage.NewCacheValue(game, false);
+                                        Storage.NewCacheValue(HasheousClient.Models.MetadataSources.IGDB, game, false);
                                         break;
 
                                     case Storage.CacheStatus.Expired:
-                            Storage.NewCacheValue(game, true);
+                                        Storage.NewCacheValue(HasheousClient.Models.MetadataSources.IGDB, game, true);
                                         break;
 
                                 }
 
-                    games.Add(new GaseousGame(game));
+                                games.Add(game);
                             }
 
-                Communications.SetSearchCache<List<GaseousGame>>(searchFields, searchBody, games);
+                            Communications.SetSearchCache<List<gaseous_server.Models.Game>>(searchFields, searchBody, games);
 
                             return games;
                         }
@@ -113,16 +111,38 @@ namespace gaseous_server.Controllers
                         {
                             // get full version of results from database
                             // this is a hacky workaround due to the readonly nature of IGDB.Model.Game IdentityOrValue fields
-                List<GaseousGame> gamesToReturn = new List<GaseousGame>();
-                foreach (GaseousGame game in searchCache)
+                            List<gaseous_server.Models.Game> gamesToReturn = new List<gaseous_server.Models.Game>();
+                            foreach (gaseous_server.Models.Game game in searchCache)
                             {
-                    Game tempGame = Games.GetGame((long)game.Id, false, false, false);
-                    gamesToReturn.Add(new GaseousGame(tempGame));
+                                gaseous_server.Models.Game? tempGame = Games.GetGame(Communications.MetadataSource, (long)game.Id);
+                                if (tempGame != null)
+                                {
+                                    gamesToReturn.Add(tempGame);
+                                }
                             }
 
                             return gamesToReturn;
                         }
                     }
+                    else
+                    {
+                        HasheousClient.Hasheous hasheous = new HasheousClient.Hasheous();
+                        Communications.ConfigureHasheousClient(ref hasheous);
+                        List<gaseous_server.Models.Game> hSearch = hasheous.GetMetadataProxy_SearchGame<gaseous_server.Models.Game>(HasheousClient.Hasheous.MetadataProvider.IGDB, PlatformId.ToString(), SearchString).ToList<gaseous_server.Models.Game>();
+
+                        List<gaseous_server.Models.Game> hGamesToReturn = new List<gaseous_server.Models.Game>();
+                        foreach (gaseous_server.Models.Game game in hSearch)
+                        {
+                            hGamesToReturn.Add(game);
+                        }
+
+                        return hGamesToReturn;
+                    }
+
+                default:
+                    return new List<gaseous_server.Models.Game>();
+            }
+        }
     }
 }
 

gaseous-server/Controllers/V1.0/SignaturesController.cs

@@ -9,6 +9,7 @@ using gaseous_signature_parser.models.RomSignatureObject;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Asp.Versioning;
+using gaseous_server.Models;
 
 // For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
 
@@ -54,11 +55,34 @@ namespace gaseous_server.Controllers
             {
                 SignatureManagement signatureManagement = new SignatureManagement();
                 return signatureManagement.GetByTosecName(TosecName);
-            } else
+            }
+            else
             {
                 return null;
             }
         }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public List<Signatures_Sources> GetSignatureSources()
+        {
+            SignatureManagement signatureManagement = new SignatureManagement();
+            return signatureManagement.GetSources();
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpDelete]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public IActionResult DeleteSignatureSource(int Id)
+        {
+            SignatureManagement signatureManagement = new SignatureManagement();
+            signatureManagement.DeleteSource(Id);
+
+            return Ok();
+        }
     }
 }
 

gaseous-server/Controllers/V1.0/SystemController.cs

@@ -38,7 +38,10 @@ namespace gaseous_server.Controllers
             List<SystemInfo.PathItem> Disks = new List<SystemInfo.PathItem>();
             foreach (GameLibrary.LibraryItem libraryItem in GameLibrary.GetLibraries)
             {
-                Disks.Add(GetDisk(libraryItem.Path));
+                SystemInfo.PathItem pathItem = GetDisk(libraryItem.Path);
+                pathItem.Name = libraryItem.Name;
+
+                Disks.Add(pathItem);
             }
             ReturnValue.Paths = Disks;
 
@@ -48,7 +51,19 @@ namespace gaseous_server.Controllers
             ReturnValue.DatabaseSize = (long)(System.Decimal)dbResponse.Rows[0][1];
 
             // platform statistics
-            sql = "SELECT Platform.`name`, grc.Count, grs.Size FROM Platform INNER JOIN (SELECT Platform.`name` AS `Name`, SUM(grs.Size) AS Size FROM Platform JOIN Games_Roms AS grs ON (grs.PlatformId = Platform.Id) GROUP BY Platform.`name`) grs ON (grs.`Name` = Platform.`name`) INNER JOIN (SELECT Platform.`name` AS `Name`, COUNT(grc.Size) AS Count FROM Platform JOIN Games_Roms AS grc ON (grc.PlatformId = Platform.Id) GROUP BY Platform.`name`) grc ON (grc.`Name` = Platform.`name`) ORDER BY Platform.`name`;";
+            sql = @"
+SELECT 
+    view_Games_Roms.PlatformId,
+    Platform.`Name`,
+    SUM(view_Games_Roms.Size) AS Size,
+    COUNT(view_Games_Roms.`Id`) AS Count
+FROM
+    view_Games_Roms
+        LEFT JOIN
+    Platform ON view_Games_Roms.PlatformId = Platform.`Id`
+        AND Platform.SourceId = 0
+GROUP BY Platform.`Name`
+ORDER BY Platform.`Name`; ";
             dbResponse = db.ExecuteCMD(sql);
             ReturnValue.PlatformStatistics = new List<SystemInfo.PlatformStatisticsItem>();
             foreach (DataRow dr in dbResponse.Rows)
@@ -69,9 +84,51 @@ namespace gaseous_server.Controllers
         [MapToApiVersion("1.1")]
         [HttpGet]
         [Route("Version")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public Version GetSystemVersion() {
-            return Assembly.GetExecutingAssembly().GetName().Version;
+        [ProducesResponseType(typeof(Dictionary<string, object>), StatusCodes.Status200OK)]
+        [AllowAnonymous]
+        public ActionResult GetSystemVersion()
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+
+            // get age ratings dictionary
+            Dictionary<int, string> ClassificationBoardsStrings = new Dictionary<int, string>();
+            foreach (IGDB.Models.AgeRatingCategory ageRatingCategory in Enum.GetValues(typeof(IGDB.Models.AgeRatingCategory)))
+            {
+                ClassificationBoardsStrings.Add((int)ageRatingCategory, ageRatingCategory.ToString());
+            }
+
+            Dictionary<int, string> AgeRatingsStrings = new Dictionary<int, string>();
+            foreach (IGDB.Models.AgeRatingTitle ageRatingTitle in Enum.GetValues(typeof(IGDB.Models.AgeRatingTitle)))
+            {
+                AgeRatingsStrings.Add((int)ageRatingTitle, ageRatingTitle.ToString());
+            }
+
+            Dictionary<string, object> retVal = new Dictionary<string, object>
+            {
+                {
+                    "AppVersion", Assembly.GetExecutingAssembly().GetName().Version.ToString()
+                },
+                {
+                    "DBSchemaVersion", db.GetDatabaseSchemaVersion().ToString()
+                },
+                {
+                    "FirstRunStatus", Config.ReadSetting<string>("FirstRunStatus", "0")
+                },
+                {
+                    "AgeRatingBoardsStrings", ClassificationBoardsStrings
+                },
+                {
+                    "AgeRatingStrings", AgeRatingsStrings
+                },
+                {
+                    "AgeRatingGroups", AgeGroups.AgeGroupingsFlat
+                },
+                {
+                    "emulatorDebugMode", Config.ReadSetting<string>("emulatorDebugMode", false.ToString()).ToLower()
+                }
+            };
+
+            return Ok(retVal);
         }
 
         [MapToApiVersion("1.0")]
@@ -80,7 +137,8 @@ namespace gaseous_server.Controllers
         [Route("VersionFile")]
         [AllowAnonymous]
         [ProducesResponseType(StatusCodes.Status200OK)]
-        public FileContentResult GetSystemVersionAsFile() {
+        public FileContentResult GetSystemVersionAsFile()
+        {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
             // get age ratings dictionary
@@ -98,14 +156,17 @@ namespace gaseous_server.Controllers
 
             string ver = "var AppVersion = \"" + Assembly.GetExecutingAssembly().GetName().Version.ToString() + "\";" + Environment.NewLine +
                 "var DBSchemaVersion = \"" + db.GetDatabaseSchemaVersion() + "\";" + Environment.NewLine +
-                "var FirstRunStatus = " + Config.ReadSetting<string>("FirstRunStatus", "0") + ";" + Environment.NewLine +
-                "var AgeRatingBoardsStrings = " + JsonSerializer.Serialize(ClassificationBoardsStrings, new JsonSerializerOptions{
+                "var FirstRunStatus = \"" + Config.ReadSetting<string>("FirstRunStatus", "0") + "\";" + Environment.NewLine +
+                "var AgeRatingBoardsStrings = " + JsonSerializer.Serialize(ClassificationBoardsStrings, new JsonSerializerOptions
+                {
                     WriteIndented = true
                 }) + ";" + Environment.NewLine +
-                "var AgeRatingStrings = " + JsonSerializer.Serialize(AgeRatingsStrings, new JsonSerializerOptions{
+                "var AgeRatingStrings = " + JsonSerializer.Serialize(AgeRatingsStrings, new JsonSerializerOptions
+                {
                     WriteIndented = true
                 }) + ";" + Environment.NewLine +
-                "var AgeRatingGroups = " + JsonSerializer.Serialize(AgeGroups.AgeGroupingsFlat, new JsonSerializerOptions{
+                "var AgeRatingGroups = " + JsonSerializer.Serialize(AgeGroups.AgeGroupingsFlat, new JsonSerializerOptions
+                {
                     WriteIndented = true
                 }) + ";" + Environment.NewLine +
                 "var emulatorDebugMode = " + Config.ReadSetting<string>("emulatorDebugMode", false.ToString()).ToLower() + ";";
@@ -251,10 +312,23 @@ namespace gaseous_server.Controllers
         [ProducesResponseType(StatusCodes.Status200OK)]
         public ActionResult GetSystemSettings()
         {
-            SystemSettingsModel systemSettingsModel = new SystemSettingsModel{
+            SystemSettingsModel systemSettingsModel = new SystemSettingsModel
+            {
                 AlwaysLogToDisk = Config.LoggingConfiguration.AlwaysLogToDisk,
                 MinimumLogRetentionPeriod = Config.LoggingConfiguration.LogRetention,
-                EmulatorDebugMode = Boolean.Parse(Config.ReadSetting<string>("emulatorDebugMode", false.ToString()))
+                EmulatorDebugMode = Boolean.Parse(Config.ReadSetting<string>("emulatorDebugMode", false.ToString())),
+                SignatureSource = new SystemSettingsModel.SignatureSourceItem()
+                {
+                    Source = Config.MetadataConfiguration.SignatureSource,
+                    HasheousHost = Config.MetadataConfiguration.HasheousHost,
+                    HasheousSubmitFixes = (bool)Config.MetadataConfiguration.HasheousSubmitFixes,
+                    HasheousAPIKey = Config.MetadataConfiguration.HasheousAPIKey
+                },
+                MetadataSources = new List<SystemSettingsModel.MetadataSourceItem>
+                {
+                    new SystemSettingsModel.MetadataSourceItem(HasheousClient.Models.MetadataSources.None, false, "", "", Config.MetadataConfiguration.DefaultMetadataSource),
+                    new SystemSettingsModel.MetadataSourceItem(HasheousClient.Models.MetadataSources.IGDB, Config.IGDB.UseHasheousProxy, Config.IGDB.ClientId, Config.IGDB.Secret, Config.MetadataConfiguration.DefaultMetadataSource)
+                }
             };
 
             return Ok(systemSettingsModel);
@@ -273,6 +347,38 @@ namespace gaseous_server.Controllers
                 Config.LoggingConfiguration.AlwaysLogToDisk = model.AlwaysLogToDisk;
                 Config.LoggingConfiguration.LogRetention = model.MinimumLogRetentionPeriod;
                 Config.SetSetting<string>("emulatorDebugMode", model.EmulatorDebugMode.ToString());
+                Config.MetadataConfiguration.SignatureSource = model.SignatureSource.Source;
+                Config.MetadataConfiguration.HasheousHost = model.SignatureSource.HasheousHost;
+                Config.MetadataConfiguration.HasheousAPIKey = model.SignatureSource.HasheousAPIKey;
+                Config.MetadataConfiguration.HasheousSubmitFixes = model.SignatureSource.HasheousSubmitFixes;
+                foreach (SystemSettingsModel.MetadataSourceItem metadataSourceItem in model.MetadataSources)
+                {
+                    // configure the default metadata source
+                    if (metadataSourceItem.Default == true)
+                    {
+                        Config.MetadataConfiguration.DefaultMetadataSource = metadataSourceItem.Source;
+                    }
+                    else
+                    {
+                        Config.MetadataConfiguration.DefaultMetadataSource = HasheousClient.Models.MetadataSources.None;
+                    }
+
+                    // configure the metadata source
+                    switch (metadataSourceItem.Source)
+                    {
+                        case HasheousClient.Models.MetadataSources.None:
+                            break;
+                        case HasheousClient.Models.MetadataSources.IGDB:
+                            Config.IGDB.UseHasheousProxy = metadataSourceItem.UseHasheousProxy;
+                            Config.IGDB.ClientId = metadataSourceItem.ClientId;
+                            Config.IGDB.Secret = metadataSourceItem.Secret;
+                            break;
+                        case HasheousClient.Models.MetadataSources.TheGamesDb:
+                            break;
+                        default:
+                            break;
+                    }
+                }
                 Config.UpdateConfig();
             }
 
@@ -281,7 +387,8 @@ namespace gaseous_server.Controllers
 
         private SystemInfo.PathItem GetDisk(string Path)
         {
-            SystemInfo.PathItem pathItem = new SystemInfo.PathItem {
+            SystemInfo.PathItem pathItem = new SystemInfo.PathItem
+            {
                 LibraryPath = Path,
                 SpaceUsed = Common.DirSize(new DirectoryInfo(Path)),
                 SpaceAvailable = new DriveInfo(Path).AvailableFreeSpace,
@@ -293,7 +400,8 @@ namespace gaseous_server.Controllers
 
         public class SystemInfo
         {
-            public Version ApplicationVersion { 
+            public Version ApplicationVersion
+            {
                 get
                 {
                     return Assembly.GetExecutingAssembly().GetName().Version;
@@ -305,6 +413,7 @@ namespace gaseous_server.Controllers
 
             public class PathItem
             {
+                public string Name { get; set; }
                 public string LibraryPath { get; set; }
                 public long SpaceUsed { get; set; }
                 public long SpaceAvailable { get; set; }
@@ -416,8 +525,7 @@ namespace gaseous_server.Controllers
                     this._Blocks = new List<ProcessQueue.QueueItemType>{
                         ProcessQueue.QueueItemType.LibraryScan,
                         ProcessQueue.QueueItemType.LibraryScanWorker,
-                        ProcessQueue.QueueItemType.TitleIngestor,
-                        ProcessQueue.QueueItemType.Rematcher
+                        ProcessQueue.QueueItemType.TitleIngestor
                     };
                     break;
 
@@ -439,32 +547,7 @@ namespace gaseous_server.Controllers
                     this.DefaultAllowedEndHours = 23;
                     this.DefaultAllowedEndMinutes = 59;
                     this._Blocks = new List<ProcessQueue.QueueItemType>{
-                        ProcessQueue.QueueItemType.OrganiseLibrary,
-                        ProcessQueue.QueueItemType.Rematcher
-                    };
-                    break;
-
-                case ProcessQueue.QueueItemType.Rematcher:
-                    this._UserManageable = true;
-                    this.DefaultInterval = 1440;
-                    this.MinimumAllowedInterval = 360;
-                    this.DefaultAllowedDays = new List<DayOfWeek>{
-                        DayOfWeek.Sunday,
-                        DayOfWeek.Monday,
-                        DayOfWeek.Tuesday,
-                        DayOfWeek.Wednesday,
-                        DayOfWeek.Thursday,
-                        DayOfWeek.Friday,
-                        DayOfWeek.Saturday
-                    };
-                    this.DefaultAllowedStartHours = 0;
-                    this.DefaultAllowedStartMinutes = 0;
-                    this.DefaultAllowedEndHours = 23;
-                    this.DefaultAllowedEndMinutes = 59;
-                    this._Blocks = new List<ProcessQueue.QueueItemType>{
-                        ProcessQueue.QueueItemType.OrganiseLibrary,
-                        ProcessQueue.QueueItemType.LibraryScan,
-                        ProcessQueue.QueueItemType.LibraryScanWorker
+                        ProcessQueue.QueueItemType.OrganiseLibrary
                     };
                     break;
 
@@ -589,7 +672,8 @@ namespace gaseous_server.Controllers
         }
         private bool _UserManageable;
         public bool UserManageable => _UserManageable;
-        public int Interval {
+        public int Interval
+        {
             get
             {
                 return int.Parse(Config.ReadSetting<string>("Interval_" + Task, DefaultInterval.ToString()));
@@ -710,5 +794,110 @@ namespace gaseous_server.Controllers
         public bool AlwaysLogToDisk { get; set; }
         public int MinimumLogRetentionPeriod { get; set; }
         public bool EmulatorDebugMode { get; set; }
+        public SignatureSourceItem SignatureSource { get; set; }
+        public List<MetadataSourceItem> MetadataSources { get; set; }
+
+        public class SignatureSourceItem
+        {
+            public HasheousClient.Models.MetadataModel.SignatureSources Source { get; set; }
+            public string HasheousHost { get; set; }
+            public string HasheousAPIKey { get; set; }
+            public bool HasheousSubmitFixes { get; set; }
+        }
+
+        public class MetadataSourceItem
+        {
+            public MetadataSourceItem()
+            {
+
+            }
+
+            public MetadataSourceItem(HasheousClient.Models.MetadataSources source, bool useHasheousProxy, string clientId, string secret, HasheousClient.Models.MetadataSources defaultSource)
+            {
+                Source = source;
+                UseHasheousProxy = useHasheousProxy;
+                ClientId = clientId;
+                Secret = secret;
+                if (Source == defaultSource)
+                {
+                    Default = true;
+                }
+                else
+                {
+                    Default = false;
+                }
+            }
+
+            public HasheousClient.Models.MetadataSources Source { get; set; }
+            public bool UseHasheousProxy { get; set; }
+            public string ClientId { get; set; }
+            public string Secret { get; set; }
+            public bool Default { get; set; }
+            public bool? Configured
+            {
+                get
+                {
+                    switch (Source)
+                    {
+                        case HasheousClient.Models.MetadataSources.None:
+                            return true;
+                        case HasheousClient.Models.MetadataSources.IGDB:
+                            if ((!String.IsNullOrEmpty(ClientId) && !String.IsNullOrEmpty(Secret)) || UseHasheousProxy == true)
+                            {
+                                return true;
+                            }
+                            else
+                            {
+                                return false;
+                            }
+                        case HasheousClient.Models.MetadataSources.TheGamesDb:
+                            if ((!String.IsNullOrEmpty(ClientId) && !String.IsNullOrEmpty(Secret)) || UseHasheousProxy == true)
+                            {
+                                return true;
+                            }
+                            else
+                            {
+                                return false;
+                            }
+                        default:
+                            return false;
+                    }
+                }
+            }
+            public bool? UsesProxy
+            {
+                get
+                {
+                    switch (Source)
+                    {
+                        case HasheousClient.Models.MetadataSources.None:
+                            return false;
+                        case HasheousClient.Models.MetadataSources.IGDB:
+                            return true;
+                        case HasheousClient.Models.MetadataSources.TheGamesDb:
+                            return true;
+                        default:
+                            return false;
+                    }
+                }
+            }
+            public bool? UsesClientIdAndSecret
+            {
+                get
+                {
+                    switch (Source)
+                    {
+                        case HasheousClient.Models.MetadataSources.None:
+                            return false;
+                        case HasheousClient.Models.MetadataSources.IGDB:
+                            return true;
+                        case HasheousClient.Models.MetadataSources.TheGamesDb:
+                            return true;
+                        default:
+                            return false;
+                    }
+                }
+            }
+        }
     }
 }

gaseous-server/Controllers/V1.1/FileSystemController.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Data;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using gaseous_server.Classes;
+using gaseous_server.Classes.Metadata;
+using IGDB.Models;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.CodeAnalysis.Scripting;
+using static gaseous_server.Classes.Metadata.AgeRatings;
+using Asp.Versioning;
+
+namespace gaseous_server.Controllers.v1_1
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiVersion("1.1")]
+    [ApiController]
+    public class FileSystemController : ControllerBase
+    {
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Authorize(Roles = "Admin")]
+        [ProducesResponseType(typeof(FileContentResult), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public ActionResult GetFileSystem(string path, bool showFiles = false)
+        {
+            try
+            {
+                if (path.Contains(".."))
+                {
+                    return NotFound();
+                }
+
+                if (Directory.Exists(path))
+                {
+                    Dictionary<string, List<Dictionary<string, string>>> allFiles = new Dictionary<string, List<Dictionary<string, string>>>();
+                    List<Dictionary<string, string>> directories = new List<Dictionary<string, string>>();
+                    string[] dirs = Directory.GetDirectories(path);
+                    Array.Sort(dirs);
+                    foreach (string dir in dirs)
+                    {
+                        DirectoryInfo directoryInfo = new DirectoryInfo(dir);
+                        directories.Add(new Dictionary<string, string> { { "name", directoryInfo.Name }, { "path", directoryInfo.FullName } });
+                    }
+                    allFiles.Add("directories", directories);
+
+                    if (showFiles == true)
+                    {
+                        List<Dictionary<string, string>> files = new List<Dictionary<string, string>>();
+                        string[] filePaths = Directory.GetFiles(path);
+                        Array.Sort(filePaths);
+                        foreach (string file in filePaths)
+                        {
+                            FileInfo fileInfo = new FileInfo(file);
+                            files.Add(new Dictionary<string, string> { { "name", fileInfo.Name }, { "path", fileInfo.FullName } });
+                        }
+                        allFiles.Add("files", files);
+                    }
+
+                    return Ok(allFiles);
+                }
+                else
+                {
+                    return NotFound();
+
+                }
+            }
+            catch (Exception ex)
+            {
+                return NotFound();
+            }
+        }
+    }
+}

gaseous-server/Controllers/V1.1/GamesController.cs

@@ -9,7 +9,6 @@ using System.Threading.Tasks;
 using Authentication;
 using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
-using IGDB.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Identity;
@@ -19,6 +18,8 @@ using Microsoft.CodeAnalysis.Scripting;
 using static gaseous_server.Classes.Metadata.AgeRatings;
 using Asp.Versioning;
 using Humanizer;
+using HasheousClient.Models.Metadata.IGDB;
+using gaseous_server.Models;
 
 namespace gaseous_server.Controllers.v1_1
 {
@@ -42,7 +43,7 @@ namespace gaseous_server.Controllers.v1_1
         [MapToApiVersion("1.1")]
         [HttpPost]
         [ProducesResponseType(typeof(GameReturnPackage), StatusCodes.Status200OK)]
-        public async Task<IActionResult> Game_v1_1(GameSearchModel model, int pageNumber = 0, int pageSize = 0)
+        public async Task<IActionResult> Game_v1_1(GameSearchModel model, int pageNumber = 0, int pageSize = 0, bool returnSummary = true, bool returnGames = true)
         {
             var user = await _userManager.GetUserAsync(User);
 
@@ -87,7 +88,7 @@ namespace gaseous_server.Controllers.v1_1
                     model.GameAgeRating.IncludeUnrated = false;
                 }
 
-                return Ok(GetGames(model, user.Id, pageNumber, pageSize));
+                return Ok(GetGames(model, user.Id, pageNumber, pageSize, returnSummary, returnGames));
             }
             else
             {
@@ -97,32 +98,34 @@ namespace gaseous_server.Controllers.v1_1
 
         [MapToApiVersion("1.1")]
         [HttpGet]
-        [Route("{GameId}/Related")]
+        [Route("{MetadataMapId}/Related")]
         [ProducesResponseType(typeof(GameReturnPackage), StatusCodes.Status200OK)]
-        public async Task<IActionResult> GameRelated(long GameId)
+        public async Task<IActionResult> GameRelated(long MetadataMapId)
         {
             var user = await _userManager.GetUserAsync(User);
 
             if (user != null)
             {
                 string IncludeUnrated = "";
-                if (user.SecurityProfile.AgeRestrictionPolicy.IncludeUnrated == true) {
+                if (user.SecurityProfile.AgeRestrictionPolicy.IncludeUnrated == true)
+                {
                     IncludeUnrated = " OR view_Games.AgeGroupId IS NULL";
                 }
 
                 Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-                string sql = "SELECT view_Games.Id, view_Games.AgeGroupId, Relation_Game_SimilarGames.SimilarGamesId FROM view_Games JOIN Relation_Game_SimilarGames ON view_Games.Id = Relation_Game_SimilarGames.GameId AND Relation_Game_SimilarGames.SimilarGamesId IN (SELECT Id FROM view_Games) WHERE view_Games.Id = @id AND (view_Games.AgeGroupId <= @agegroupid" + IncludeUnrated + ")";
+                string sql = "SELECT view_Games.Id, view_Games.AgeGroupId, Relation_Game_SimilarGames.SimilarGamesId FROM view_Games JOIN Relation_Game_SimilarGames ON view_Games.Id = Relation_Game_SimilarGames.GameId AND view_Games.GameIdType = Relation_Game_SimilarGames.GameSourceId AND Relation_Game_SimilarGames.SimilarGamesId IN (SELECT Id FROM view_Games) WHERE view_Games.Id = @id AND (view_Games.AgeGroupId <= @agegroupid" + IncludeUnrated + ")";
                 Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("id", GameId);
+                dbDict.Add("id", MetadataMapId);
                 dbDict.Add("agegroupid", (int)user.SecurityProfile.AgeRestrictionPolicy.MaximumAgeRestriction);
 
-                List<IGDB.Models.Game> RetVal = new List<IGDB.Models.Game>();
+                List<Models.Game> RetVal = new List<Models.Game>();
 
                 DataTable dbResponse = db.ExecuteCMD(sql, dbDict);
 
                 foreach (DataRow dr in dbResponse.Rows)
                 {
-                    RetVal.Add(Classes.Metadata.Games.GetGame((long)dr["SimilarGamesId"], false, false, false));
+                    MetadataMap.MetadataMapItem metadataMap = Classes.MetadataManagement.GetMetadataMap(MetadataMapId).PreferredMetadataMapItem;
+                    RetVal.Add(Classes.Metadata.Games.GetGame(metadataMap.SourceType, (long)dr["SimilarGamesId"]));
                 }
 
                 GameReturnPackage gameReturn = new GameReturnPackage(RetVal.Count, RetVal);
@@ -187,7 +190,7 @@ namespace gaseous_server.Controllers.v1_1
             }
         }
 
-        public static GameReturnPackage GetGames(GameSearchModel model, string userid, int pageNumber = 0, int pageSize = 0)
+        public static GameReturnPackage GetGames(GameSearchModel model, string userid, int pageNumber = 0, int pageSize = 0, bool returnSummary = true, bool returnGames = true)
         {
             string whereClause = "";
             string havingClause = "";
@@ -302,7 +305,7 @@ namespace gaseous_server.Controllers.v1_1
             string platformWhereClause = "";
             if (model.Platform.Count > 0)
             {
-                tempVal = " AND Games_Roms.PlatformId IN (";
+                tempVal = " AND view_Games_Roms.PlatformId IN (";
                 for (int i = 0; i < model.Platform.Count; i++)
                 {
                     if (i > 0)
@@ -479,11 +482,15 @@ namespace gaseous_server.Controllers.v1_1
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
             string sql = @"
+SET SESSION sql_mode=(SELECT REPLACE(@@sql_mode,'ONLY_FULL_GROUP_BY',''));
 SELECT DISTINCT
     Game.Id,
+    Game.MetadataMapId,
+    Game.GameIdType,
     Game.`Name`,
     Game.NameThe,
     Game.Slug,
+    Game.Summary,
     Game.PlatformId,
     Game.TotalRating,
     Game.TotalRatingCount,
@@ -504,30 +511,26 @@ SELECT DISTINCT
 FROM
     (SELECT DISTINCT
         Game.*,
-            CASE
-                WHEN Game.`Name` LIKE 'The %' THEN CONCAT(TRIM(SUBSTR(Game.`Name` FROM 4)), ', The')
-                ELSE Game.`Name`
-            END AS NameThe,
-            Games_Roms.PlatformId,
+            view_Games_Roms.PlatformId,
             AgeGroup.AgeGroupId,
-            COUNT(Games_Roms.Id) AS RomCount
+            COUNT(view_Games_Roms.Id) AS RomCount
     FROM
-        Game
+        view_GamesWithRoms AS Game
     LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId
-    LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId" + platformWhereClause + @"
+    LEFT JOIN view_Games_Roms ON Game.Id = view_Games_Roms.GameId" + platformWhereClause + @"
     LEFT JOIN AlternativeName ON Game.Id = AlternativeName.Game " + nameWhereClause + @"
     GROUP BY Game.Id
     HAVING RomCount > 0) Game
         LEFT JOIN
     (SELECT 
-        Games_Roms.GameId, COUNT(GameState.Id) AS RomSaveCount
+        view_Games_Roms.GameId, COUNT(GameState.Id) AS RomSaveCount
     FROM
         GameState
-    JOIN Games_Roms ON GameState.RomId = Games_Roms.Id
+    JOIN view_Games_Roms ON GameState.RomId = view_Games_Roms.Id
     WHERE
         GameState.IsMediaGroup = 0
             AND GameState.UserId = @userid
-    GROUP BY Games_Roms.GameId) RomSavedStates ON Game.Id = RomSavedStates.GameId
+    GROUP BY view_Games_Roms.GameId) RomSavedStates ON Game.Id = RomSavedStates.GameId
         LEFT JOIN
     (SELECT 
         RomMediaGroup.GameId,
@@ -537,38 +540,47 @@ FROM
     JOIN GameState ON RomMediaGroup.Id = GameState.RomId
         AND GameState.IsMediaGroup = 1
         AND GameState.UserId = @userid
-    GROUP BY RomMediaGroup.GameId) RomGroupSavedStates ON Game.Id = RomGroupSavedStates.GameId
+    GROUP BY RomMediaGroup.GameId) RomGroupSavedStates ON Game.MetadataMapId = RomGroupSavedStates.GameId
         LEFT JOIN
-    Relation_Game_Genres ON Game.Id = Relation_Game_Genres.GameId
+    Relation_Game_Genres ON Game.Id = Relation_Game_Genres.GameId AND Relation_Game_Genres.GameSourceId = Game.GameIdType
         LEFT JOIN
-    Relation_Game_GameModes ON Game.Id = Relation_Game_GameModes.GameId
+    Relation_Game_GameModes ON Game.Id = Relation_Game_GameModes.GameId AND Relation_Game_GameModes.GameSourceId = Game.GameIdType
         LEFT JOIN
-    Relation_Game_PlayerPerspectives ON Game.Id = Relation_Game_PlayerPerspectives.GameId
+    Relation_Game_PlayerPerspectives ON Game.Id = Relation_Game_PlayerPerspectives.GameId AND Relation_Game_PlayerPerspectives.GameSourceId = Game.GameIdType
         LEFT JOIN
-    Relation_Game_Themes ON Game.Id = Relation_Game_Themes.GameId
+    Relation_Game_Themes ON Game.Id = Relation_Game_Themes.GameId AND Relation_Game_Themes.GameSourceId = Game.GameIdType
         LEFT JOIN
-    Favourites ON Game.Id = Favourites.GameId AND Favourites.UserId = @userid " + whereClause + " " + havingClause + " " + orderByClause;
-            List<Games.MinimalGameItem> RetVal = new List<Games.MinimalGameItem>();
+    Favourites ON Game.MetadataMapId = Favourites.GameId AND Favourites.UserId = @userid " + whereClause + " " + havingClause + " " + orderByClause;
 
-            DataTable dbResponse = db.ExecuteCMD(sql, whereParams);
+            // if (returnGames == true)
+            // {
+            //     sql += " LIMIT @pageOffset, @pageSize";
+            //     whereParams.Add("pageOffset", pageSize * (pageNumber - 1));
+            //     whereParams.Add("pageSize", pageSize);
+            // }
+
+            DataTable dbResponse = db.ExecuteCMD(sql, whereParams, new Database.DatabaseMemoryCacheOptions(CacheEnabled: true, ExpirationSeconds: 60));
 
             // get count
-            int RecordCount = dbResponse.Rows.Count;
+            int? RecordCount = null;
+            if (returnSummary == true)
+            {
+                RecordCount = dbResponse.Rows.Count;
+            }
 
             // compile data for return
-            int pageOffset = pageSize * (pageNumber - 1);
-            for (int i = pageOffset; i < dbResponse.Rows.Count; i++)
+            List<Games.MinimalGameItem>? RetVal = null;
+            if (returnGames == true)
             {
-                if (pageNumber != 0 && pageSize != 0)
+                RetVal = new List<Games.MinimalGameItem>();
+                foreach (int i in Enumerable.Range(0, dbResponse.Rows.Count))
                 {
-                    if (i >= (pageOffset + pageSize))
-                    {
-                        break;
-                    }
-                }
+                    Models.Game retGame = Storage.BuildCacheObject<Models.Game>(new Models.Game(), dbResponse.Rows[i]);
+                    retGame.MetadataMapId = (long)dbResponse.Rows[i]["MetadataMapId"];
+                    retGame.MetadataSource = (HasheousClient.Models.MetadataSources)dbResponse.Rows[i]["GameIdType"];
 
-                Game retGame = Storage.BuildCacheObject<Game>(new Game() , dbResponse.Rows[i]);
                     Games.MinimalGameItem retMinGame = new Games.MinimalGameItem(retGame);
+                    retMinGame.Index = i;
                     if (dbResponse.Rows[i]["RomSaveCount"] != DBNull.Value || dbResponse.Rows[i]["MediaGroupSaveCount"] != DBNull.Value)
                     {
                         retMinGame.HasSavedGame = true;
@@ -588,26 +600,53 @@ FROM
 
                     RetVal.Add(retMinGame);
                 }
+            }
+
+            Dictionary<string, int>? AlphaList = null;
+            if (returnSummary == true)
+            {
+                AlphaList = new Dictionary<string, int>();
 
                 // build alpha list
-            Dictionary<string, int> AlphaList = new Dictionary<string, int>();
-            int CurrentPage = 0;
-            int NextPageIndex = 0;
+                if (orderByField == "NameThe" || orderByField == "Name")
+                {
+                    int CurrentPage = 1;
+                    int NextPageIndex = pageSize;
+
+                    string alphaSearchField;
+                    if (orderByField == "NameThe")
+                    {
+                        alphaSearchField = "NameThe";
+                    }
+                    else
+                    {
+                        alphaSearchField = "Name";
+                    }
+
                     for (int i = 0; i < dbResponse.Rows.Count; i++)
                     {
-                string firstChar = dbResponse.Rows[i]["NameThe"].ToString().Substring(0, 1).ToUpperInvariant();
-                if (!"ABCDEFGHIJKLMNOPQRSTUVWXYZ".Contains(firstChar))
+                        if (NextPageIndex == i + 1)
                         {
-                    firstChar = "#";
+                            NextPageIndex += pageSize;
+                            CurrentPage += 1;
                         }
+
+                        string firstChar = dbResponse.Rows[i][alphaSearchField].ToString().Substring(0, 1).ToUpperInvariant();
+                        if ("ABCDEFGHIJKLMNOPQRSTUVWXYZ".Contains(firstChar))
+                        {
                             if (!AlphaList.ContainsKey(firstChar))
                             {
                                 AlphaList.Add(firstChar, CurrentPage);
                             }
-                if (NextPageIndex == i)
+                        }
+                        else
                         {
-                    NextPageIndex += pageSize;
-                    CurrentPage += 1;
+                            if (!AlphaList.ContainsKey("#"))
+                            {
+                                AlphaList.Add("#", 1);
+                            }
+                        }
+                    }
                 }
             }
 
@@ -628,12 +667,12 @@ FROM
 
             }
 
-            public GameReturnPackage(int Count, List<Game> Games)
+            public GameReturnPackage(int Count, List<Models.Game> Games)
             {
                 this.Count = Count;
 
                 List<Games.MinimalGameItem> minimalGames = new List<Games.MinimalGameItem>();
-                foreach (Game game in Games)
+                foreach (Models.Game game in Games)
                 {
                     minimalGames.Add(new Classes.Metadata.Games.MinimalGameItem(game));
                 }
@@ -641,9 +680,9 @@ FROM
                 this.Games = minimalGames;
             }
 
-            public int Count { get; set; }
-            public List<Games.MinimalGameItem> Games { get; set; } = new List<Games.MinimalGameItem>();
-            public Dictionary<string, int> AlphaList { get; set; }
+            public int? Count { get; set; }
+            public List<Games.MinimalGameItem>? Games { get; set; } = new List<Games.MinimalGameItem>();
+            public Dictionary<string, int>? AlphaList { get; set; }
         }
     }
 }

gaseous-server/Controllers/V1.1/StateManagerController.cs

@@ -6,6 +6,8 @@ using Authentication;
 using Microsoft.AspNetCore.Identity;
 using System.Data;
 using Asp.Versioning;
+using System.IO.Compression;
+using gaseous_server.Classes.Metadata;
 
 namespace gaseous_server.Controllers.v1_1
 {
@@ -233,11 +235,11 @@ namespace gaseous_server.Controllers.v1_1
         [ProducesResponseType(StatusCodes.Status404NotFound)]
         [Route("{RomId}/{StateId}/State/")]
         [Route("{RomId}/{StateId}/State/savestate.state")]
-        public async Task<ActionResult> GetStateDataAsync(long RomId, long StateId, bool IsMediaGroup = false)
+        public async Task<ActionResult> GetStateDataAsync(long RomId, long StateId, bool IsMediaGroup = false, bool StateOnly = false)
         {
             var user = await _userManager.GetUserAsync(User);
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT Zipped, State FROM GameState WHERE Id = @id AND RomId = @romid AND IsMediaGroup = @ismediagroup AND UserId = @userid;";
+            string sql = "SELECT * FROM GameState WHERE Id = @id AND RomId = @romid AND IsMediaGroup = @ismediagroup AND UserId = @userid;";
             Dictionary<string, object> dbDict = new Dictionary<string, object>
             {
                 { "id", StateId },
@@ -254,7 +256,27 @@ namespace gaseous_server.Controllers.v1_1
             }
             else
             {
-                string filename = "savestate.state";
+                // get rom data
+                string romName = "";
+                string romMd5 = "";
+                string romSha1 = "";
+                if (IsMediaGroup == false)
+                {
+                    Roms.GameRomItem romItem = Roms.GetRom(RomId);
+                    romName = romItem.Name;
+                    romMd5 = romItem.Md5;
+                    romSha1 = romItem.Sha1;
+                }
+                else
+                {
+                    RomMediaGroup.GameRomMediaGroupItem mediaGroupItem = RomMediaGroup.GetMediaGroup(RomId);
+                    Models.Game game = Games.GetGame(Communications.MetadataSource, mediaGroupItem.GameId);
+                    Classes.Common.hashObject hashObject = new Classes.Common.hashObject(Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, mediaGroupItem.Id.ToString() + ".zip"));
+                    romName = game.Name;
+                    romMd5 = hashObject.md5hash;
+                    romSha1 = hashObject.sha1hash;
+                }
+
                 byte[] bytes;
                 if ((bool)data.Rows[0]["Zipped"] == false)
                 {
@@ -264,7 +286,85 @@ namespace gaseous_server.Controllers.v1_1
                 {
                     bytes = Common.Decompress((byte[])data.Rows[0]["State"]);
                 }
-                string contentType = "application/octet-stream";
+                string contentType = "";
+                string filename = ((DateTime)data.Rows[0]["StateDateTime"]).ToString("yyyy-MM-ddTHH-mm-ss") + "-" + Path.GetFileNameWithoutExtension(romName);
+
+
+                if (StateOnly == true)
+                {
+                    contentType = "application/octet-stream";
+                    filename = filename + ".state";
+                }
+                else
+                {
+                    contentType = "application/zip";
+                    filename = filename + ".zip";
+
+                    Dictionary<string, object> RomInfo = new Dictionary<string, object>
+                     {
+                         { "Name", romName },
+                         { "StateDateTime", data.Rows[0]["StateDateTime"] },
+                         { "StateName", data.Rows[0]["Name"] }
+                     };
+                    if ((int)data.Rows[0]["IsMediaGroup"] == 0)
+                    {
+                        RomInfo.Add("MD5", romMd5);
+                        RomInfo.Add("SHA1", romSha1);
+                        RomInfo.Add("Type", "ROM");
+                    }
+                    else
+                    {
+                        RomInfo.Add("Type", "Media Group");
+                        RomInfo.Add("MediaGroupId", (long)data.Rows[0]["RomId"]);
+                    }
+                    string RomInfoString = Newtonsoft.Json.JsonConvert.SerializeObject(RomInfo, Newtonsoft.Json.Formatting.Indented, new Newtonsoft.Json.JsonSerializerSettings { NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore });
+
+                    // compile zip file
+                    using (var compressedFileStream = new MemoryStream())
+                    {
+                        List<Dictionary<string, object>> Attachments = new List<Dictionary<string, object>>();
+                        Attachments.Add(new Dictionary<string, object>
+                         {
+                             { "Name", "savestate.state" },
+                             { "Body", bytes }
+                         });
+                        // check if value is dbnull
+                        if (data.Rows[0]["Screenshot"] != DBNull.Value)
+                        {
+                            Attachments.Add(new Dictionary<string, object>
+                             {
+                                 { "Name", "screenshot.jpg" },
+                                 { "Body", (byte[])data.Rows[0]["Screenshot"] }
+                             });
+                        }
+                        Attachments.Add(new Dictionary<string, object>
+                         {
+                             { "Name", "rominfo.json" },
+                             { "Body", System.Text.Encoding.UTF8.GetBytes(RomInfoString) }
+                         });
+
+                        //Create an archive and store the stream in memory.
+                        using (var zipArchive = new ZipArchive(compressedFileStream, ZipArchiveMode.Create, false))
+                        {
+                            foreach (var Attachment in Attachments)
+                            {
+                                //Create a zip entry for each attachment
+                                var zipEntry = zipArchive.CreateEntry(Attachment["Name"].ToString());
+
+                                //Get the stream of the attachment
+                                using (var originalFileStream = new MemoryStream((byte[])Attachment["Body"]))
+                                using (var zipEntryStream = zipEntry.Open())
+                                {
+                                    //Copy the attachment stream to the zip entry stream
+                                    originalFileStream.CopyTo(zipEntryStream);
+                                }
+                            }
+                        }
+
+                        //return new FileContentResult(compressedFileStream.ToArray(), "application/zip") { FileDownloadName = filename };
+                        bytes = compressedFileStream.ToArray();
+                    }
+                }
 
                 var cd = new System.Net.Mime.ContentDisposition
                 {
@@ -279,6 +379,156 @@ namespace gaseous_server.Controllers.v1_1
             }
         }
 
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost]
+        [Authorize]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [RequestSizeLimit(long.MaxValue)]
+        [Consumes("multipart/form-data")]
+        [DisableRequestSizeLimit, RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue, ValueLengthLimit = int.MaxValue)]
+        [Route("Upload")]
+        public async Task<ActionResult> UploadStateDataAsync(IFormFile file, long RomId = 0, bool IsMediaGroup = false)
+        {
+            // get user
+            var user = await _userManager.GetUserAsync(User);
+
+            if (file.Length > 0)
+            {
+                MemoryStream fileContent = new MemoryStream();
+                file.CopyTo(fileContent);
+
+                // test if file is a zip file
+                try
+                {
+                    using (var zipArchive = new ZipArchive(fileContent, ZipArchiveMode.Read, false))
+                    {
+                        foreach (var entry in zipArchive.Entries)
+                        {
+                            if (entry.FullName == "rominfo.json")
+                            {
+                                using (var stream = entry.Open())
+                                using (var reader = new StreamReader(stream))
+                                {
+                                    string RomInfoString = reader.ReadToEnd();
+                                    Dictionary<string, object> RomInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(RomInfoString);
+
+                                    // get rom data
+                                    Roms.GameRomItem romItem;
+
+                                    try
+                                    {
+                                        romItem = Roms.GetRom((string)RomInfo["MD5"]);
+                                    }
+                                    catch (Roms.InvalidRomHash)
+                                    {
+                                        return NotFound();
+                                    }
+
+                                    // get state data
+                                    byte[] StateData = null;
+                                    byte[] ScreenshotData = null;
+                                    string StateName = RomInfo["StateName"].ToString();
+                                    DateTime StateDateTime = DateTime.Parse(RomInfo["StateDateTime"].ToString());
+                                    IsMediaGroup = RomInfo["Type"].ToString() == "Media Group" ? true : false;
+
+                                    if (zipArchive.GetEntry("savestate.state") != null)
+                                    {
+                                        using (var stateStream = zipArchive.GetEntry("savestate.state").Open())
+                                        using (var stateReader = new MemoryStream())
+                                        {
+                                            stateStream.CopyTo(stateReader);
+                                            StateData = stateReader.ToArray();
+                                        }
+                                    }
+                                    if (zipArchive.GetEntry("screenshot.jpg") != null)
+                                    {
+                                        using (var screenshotStream = zipArchive.GetEntry("screenshot.jpg").Open())
+                                        using (var screenshotReader = new MemoryStream())
+                                        {
+                                            screenshotStream.CopyTo(screenshotReader);
+                                            ScreenshotData = screenshotReader.ToArray();
+                                        }
+                                    }
+
+                                    // save state
+                                    Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                                    string sql = "INSERT INTO GameState (UserId, RomId, IsMediaGroup, StateDateTime, Name, Screenshot, State, Zipped) VALUES (@userid, @romid, @ismediagroup, @statedatetime, @name, @screenshot, @state, @zipped); SELECT LAST_INSERT_ID();";
+                                    Dictionary<string, object> dbDict = new Dictionary<string, object>
+                                     {
+                                         { "userid", user.Id },
+                                         { "romid", romItem.Id },
+                                         { "ismediagroup", IsMediaGroup },
+                                         { "statedatetime", StateDateTime },
+                                         { "name", StateName },
+                                         { "screenshot", ScreenshotData },
+                                         { "state", Common.Compress(StateData) },
+                                         { "zipped", true }
+                                     };
+                                    DataTable data = db.ExecuteCMD(sql, dbDict);
+
+                                    RomInfo.Add("RomId", romItem.Id);
+                                    RomInfo.Add("Management", "Managed");
+                                    return Ok(RomInfo);
+                                }
+                            }
+                        }
+                    }
+
+                    return BadRequest("File is not a valid Gaseous state file.");
+                }
+                catch
+                {
+                    // not a zip file
+                    if (RomId != 0)
+                    {
+                        // get rom data
+                        Roms.GameRomItem romItem;
+
+                        try
+                        {
+                            romItem = Roms.GetRom(RomId);
+                        }
+                        catch (Roms.InvalidRomHash)
+                        {
+                            return NotFound();
+                        }
+
+                        // save state
+                        Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                        string sql = "INSERT INTO GameState (UserId, RomId, IsMediaGroup, StateDateTime, Name, Screenshot, State, Zipped) VALUES (@userid, @romid, @ismediagroup, @statedatetime, @name, @screenshot, @state, @zipped); SELECT LAST_INSERT_ID();";
+                        Dictionary<string, object> dbDict = new Dictionary<string, object>
+                         {
+                             { "userid", user.Id },
+                             { "romid", RomId },
+                             { "ismediagroup", IsMediaGroup },
+                             { "statedatetime", DateTime.UtcNow },
+                             { "name", "" },
+                             { "screenshot", null },
+                             { "state", Common.Compress(fileContent.ToArray()) },
+                             { "zipped", true }
+                         };
+                        DataTable data = db.ExecuteCMD(sql, dbDict);
+
+                        return Ok(new Dictionary<string, object>
+                         {
+                             { "RomId", RomId },
+                             { "Management", "Unmanaged" }
+                         });
+                    }
+                    else
+                    {
+                        return BadRequest("No rom id provided.");
+                    }
+                }
+            }
+            else
+            {
+                return BadRequest("File is empty.");
+            }
+        }
+
         private Models.GameStateItem BuildGameStateItem(DataRow dr)
         {
             bool HasScreenshot = true;

gaseous-server/Controllers/V1.1/StatisticsController.cs

@@ -32,15 +32,15 @@ namespace gaseous_server.Controllers.v1_1
         [Authorize]
         [ProducesResponseType(typeof(Models.StatisticsModel), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        [Route("Games/{GameId}/")]
-        public async Task<ActionResult> NewRecordStatistics(long GameId)
+        [Route("Games/{GameId}/{PlatformId}/{RomId}")]
+        public async Task<ActionResult> NewRecordStatistics(long GameId, long PlatformId, long RomId, bool IsMediaGroup)
         {
             var user = await _userManager.GetUserAsync(User);
 
             if (user != null)
             {
                 Statistics statistics = new Statistics();
-                return Ok(statistics.RecordSession(Guid.Empty, GameId, user.Id));
+                return Ok(statistics.RecordSession(Guid.Empty, GameId, PlatformId, RomId, IsMediaGroup, user.Id));
             }
             else
             {
@@ -54,15 +54,15 @@ namespace gaseous_server.Controllers.v1_1
         [Authorize]
         [ProducesResponseType(typeof(Models.StatisticsModel), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        [Route("Games/{GameId}/{SessionId}")]
-        public async Task<ActionResult> SubsequentRecordStatistics(long GameId, Guid SessionId)
+        [Route("Games/{GameId}/{PlatformId}/{RomId}/{SessionId}")]
+        public async Task<ActionResult> SubsequentRecordStatistics(long GameId, long PlatformId, long RomId, Guid SessionId, bool IsMediaGroup)
         {
             var user = await _userManager.GetUserAsync(User);
 
             if (user != null)
             {
                 Statistics statistics = new Statistics();
-                return Ok(statistics.RecordSession(SessionId, GameId, user.Id));
+                return Ok(statistics.RecordSession(SessionId, GameId, PlatformId, RomId, IsMediaGroup, user.Id));
             }
             else
             {

gaseous-server/Controllers/V1.1/UserProfileController.cs

@@ -0,0 +1,137 @@
+using Asp.Versioning;
+using Authentication;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+
+namespace gaseous_server.Controllers
+{
+    [ApiController]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiVersion("1.0")]
+    [ApiVersion("1.1")]
+    [Authorize]
+    public class UserProfileController : ControllerBase
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+
+        public UserProfileController(
+            UserManager<ApplicationUser> userManager,
+            SignInManager<ApplicationUser> signInManager
+        )
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("{UserId}")]
+        [ProducesResponseType(typeof(Models.UserProfile), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ResponseCache(CacheProfileName = "Default30")]
+        public ActionResult GetUserProfile(string UserId)
+        {
+            Classes.UserProfile profile = new Classes.UserProfile();
+            Models.UserProfile RetVal = profile.GetUserProfile(UserId);
+            return Ok(RetVal);
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPut]
+        [Route("{UserId}")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<ActionResult> UpdateUserProfileAsync(string UserId, Models.UserProfile profile)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user.ProfileId.ToString() != UserId)
+            {
+                return Unauthorized();
+            }
+
+            Classes.UserProfile userProfile = new Classes.UserProfile();
+            userProfile.UpdateUserProfile(user.Id, profile);
+            return Ok();
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPut]
+        [ProducesResponseType(typeof(List<IFormFile>), StatusCodes.Status200OK)]
+        [RequestSizeLimit(long.MaxValue)]
+        [Consumes("multipart/form-data")]
+        [DisableRequestSizeLimit, RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue, ValueLengthLimit = int.MaxValue)]
+        [Route("{UserId}/{ProfileImageType}")]
+        public async Task<ActionResult> UpdateAvatarAsync(string UserId, Classes.UserProfile.ImageType ProfileImageType, IFormFile file)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user.ProfileId.ToString() != UserId)
+            {
+                return Unauthorized();
+            }
+
+            if (file.Length > 0)
+            {
+                using (var ms = new MemoryStream())
+                {
+                    file.CopyTo(ms);
+                    byte[] fileBytes = ms.ToArray();
+
+                    Classes.UserProfile userProfile = new Classes.UserProfile();
+                    userProfile.UpdateImage(ProfileImageType, UserId, user.Id, file.FileName, fileBytes);
+                }
+            }
+
+            return Ok();
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("{UserId}/{ProfileImageType}")]
+        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ResponseCache(CacheProfileName = "5Minute")]
+        public async Task<ActionResult> GetAvatarAsync(string UserId, Classes.UserProfile.ImageType ProfileImageType)
+        {
+            Classes.UserProfile userProfile = new Classes.UserProfile();
+
+            Models.ImageItem image = userProfile.GetImage(ProfileImageType, UserId);
+
+            if (image == null)
+            {
+                return NotFound();
+            }
+            else
+            {
+                return File(image.content, image.mimeType, UserId + image.extension);
+            }
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpDelete]
+        [Route("{UserId}/{ProfileImageType}")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        public async Task<ActionResult> DeleteAvatarAsync(string UserId, Classes.UserProfile.ImageType ProfileImageType)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user.ProfileId.ToString() != UserId)
+            {
+                return Unauthorized();
+            }
+
+            Classes.UserProfile userProfile = new Classes.UserProfile();
+            userProfile.DeleteImage(ProfileImageType, user.Id);
+
+            return Ok();
+        }
+    }
+}

gaseous-server/Models/GaseousGame.cs

@@ -5,48 +5,22 @@ using Swashbuckle.AspNetCore.SwaggerGen;
 
 namespace gaseous_server.Models
 {
-    public class GaseousGame : IGDB.Models.Game
-    {
-        public GaseousGame()
+    public class Game : HasheousClient.Models.Metadata.IGDB.Game
     {
+        [NoDatabase]
+        public bool IsFavourite { get; set; } = false;
 
-        }
-
-        public GaseousGame(IGDB.Models.Game game)
-        {
-            var targetType = this.GetType();
-            var sourceType = game.GetType();
-            foreach(var prop in targetType.GetProperties(BindingFlags.Instance | BindingFlags.Public| BindingFlags.SetProperty))
-            {
-                // check whether source object has the the property
-                var sp = sourceType.GetProperty(prop.Name);
-                if (sp != null)
-                {
-                    // if yes, copy the value to the matching property
-                    var value = sp.GetValue(game, null);
-                    prop.SetValue(this, value, null);
-                }
-            }
-        }
-
+        [NoDatabase]
         public bool HasSavedGame { get; set; } = false;
 
-        public IGDB.Models.Cover? CoverItem
-        {
-            get
-            {
-                if (this.Cover != null)
-                {
-                    if (this.Cover.Id != null)
-                    {
-                        IGDB.Models.Cover cover = Covers.GetCover(Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(this), false);
+        [NoDatabase]
+        public long MetadataMapId { get; set; }
 
-                        return cover;
-                    }
+        [NoDatabase]
+        public HasheousClient.Models.MetadataSources MetadataSource { get; set; }
     }
 
-                return null;
-            }
-        }
+    internal class NoDatabaseAttribute : Attribute
+    {
     }
 }

gaseous-server/Models/ImageItem.cs

@@ -0,0 +1,9 @@
+namespace gaseous_server.Models
+{
+    public class ImageItem
+    {
+        public byte[] content { get; set; }
+        public string mimeType { get; set; }
+        public string extension { get; set; }
+    }
+}

gaseous-server/Models/MetadataMap.cs

@@ -0,0 +1,77 @@
+using gaseous_server.Classes.Metadata;
+using HasheousClient.Models;
+
+namespace gaseous_server.Models
+{
+    public class MetadataMap
+    {
+        public long Id { get; set; }
+        public long PlatformId { get; set; }
+        public string SignatureGameName { get; set; }
+        public List<MetadataMapItem> MetadataMapItems { get; set; }
+        public MetadataMapItem? PreferredMetadataMapItem
+        {
+            get
+            {
+                if (MetadataMapItems == null || MetadataMapItems.Count == 0)
+                {
+                    return null;
+                }
+                return MetadataMapItems.FirstOrDefault(mmi => mmi.Preferred);
+            }
+        }
+
+        public class MetadataMapItem
+        {
+            public HasheousClient.Models.MetadataSources SourceType { get; set; }
+            public long SourceId { get; set; }
+            public bool Preferred { get; set; }
+            public string SourceSlug
+            {
+                get
+                {
+                    string slug = "";
+                    switch (SourceType)
+                    {
+                        case MetadataSources.IGDB:
+                            Game game = Games.GetGame(SourceType, (long)SourceId);
+                            if (game != null)
+                            {
+                                slug = game.Slug;
+                            }
+                            break;
+
+                        default:
+                            slug = SourceId.ToString();
+                            break;
+                    }
+
+                    return slug;
+                }
+            }
+            public string link
+            {
+                get
+                {
+                    string link = "";
+                    switch (SourceType)
+                    {
+                        case MetadataSources.IGDB:
+                            link = $"https://www.igdb.com/games/{SourceSlug}";
+                            break;
+
+                        case MetadataSources.TheGamesDb:
+                            link = $"https://thegamesdb.net/game.php?id={SourceId}";
+                            break;
+
+                        default:
+                            link = "";
+                            break;
+                    }
+
+                    return link;
+                }
+            }
+        }
+    }
+}

gaseous-server/Models/PlatformMapping.cs

@@ -8,15 +8,13 @@ using System.Web;
 using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
 using gaseous_server.Controllers;
-using IGDB.Models;
+using HasheousClient.Models.Metadata.IGDB;
 using Newtonsoft.Json;
 
 namespace gaseous_server.Models
 {
     public class PlatformMapping
     {
-        private static Dictionary<string, PlatformMapItem> PlatformMapCache = new Dictionary<string, PlatformMapItem>();
-
         /// <summary>
         /// Updates the platform map from the embedded platform map resource
         /// </summary>
@@ -27,7 +25,8 @@ namespace gaseous_server.Models
             {
                 string rawJson = reader.ReadToEnd();
                 List<PlatformMapItem> platforms = new List<PlatformMapItem>();
-                Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings{
+                Newtonsoft.Json.JsonSerializerSettings jsonSerializerSettings = new JsonSerializerSettings
+                {
                     MaxDepth = 64
                 };
                 platforms = Newtonsoft.Json.JsonConvert.DeserializeObject<List<PlatformMapItem>>(rawJson, jsonSerializerSettings);
@@ -47,7 +46,7 @@ namespace gaseous_server.Models
                         }
                         else
                         {
-                            WritePlatformMap(mapItem, true, true);
+                            WritePlatformMap(mapItem, true, true, true);
                             Logging.Log(Logging.LogType.Information, "Platform Map", "Overwriting " + mapItem.IGDBName + " with default values.");
                         }
                     }
@@ -55,7 +54,7 @@ namespace gaseous_server.Models
                     {
                         Logging.Log(Logging.LogType.Information, "Platform Map", "Importing " + mapItem.IGDBName + " from predefined data.");
                         // doesn't exist - add it
-                        WritePlatformMap(mapItem, false, true);
+                        WritePlatformMap(mapItem, false, true, true);
                     }
                 }
             }
@@ -73,8 +72,8 @@ namespace gaseous_server.Models
 
             foreach (PlatformMapItem mapItem in platforms)
             {
-                // get the IGDB platform data
-                Platform platform = Platforms.GetPlatform(mapItem.IGDBId);
+                // insert dummy platform data - it'll be cleaned up on the first metadata refresh
+                Platform platform = CreateDummyPlatform(mapItem);
 
                 try
                 {
@@ -93,49 +92,62 @@ namespace gaseous_server.Models
             }
         }
 
+        private static Platform CreateDummyPlatform(PlatformMapItem mapItem)
+        {
+            Platform platform = new Platform
+            {
+                Id = mapItem.IGDBId,
+                Name = mapItem.IGDBName,
+                Slug = mapItem.IGDBSlug,
+                AlternativeName = mapItem.AlternateNames.FirstOrDefault()
+            };
+
+            if (Storage.GetCacheStatus(HasheousClient.Models.MetadataSources.None, "Platform", mapItem.IGDBId) == Storage.CacheStatus.NotPresent)
+            {
+                Storage.NewCacheValue(HasheousClient.Models.MetadataSources.None, platform);
+            }
+
+            if (Storage.GetCacheStatus(HasheousClient.Models.MetadataSources.IGDB, "Platform", mapItem.IGDBId) == Storage.CacheStatus.NotPresent)
+            {
+                Storage.NewCacheValue(HasheousClient.Models.MetadataSources.IGDB, platform);
+            }
+
+            return platform;
+        }
+
         public static List<PlatformMapItem> PlatformMap
         {
             get
             {
+                // if (Database.DatabaseMemoryCache.GetCacheObject("PlatformMap") != null)
+                // {
+                //     return (List<PlatformMapItem>)Database.DatabaseMemoryCache.GetCacheObject("PlatformMap");
+                // }
                 Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
                 string sql = "SELECT * FROM PlatformMap";
-                DataTable data = db.ExecuteCMD(sql);
+                DataTable data = db.ExecuteCMD(sql); //, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromSeconds(5).Ticks));
 
                 List<PlatformMapItem> platformMaps = new List<PlatformMapItem>();
                 foreach (DataRow row in data.Rows)
                 {
                     long mapId = (long)row["Id"];
-                    if (PlatformMapCache.ContainsKey(mapId.ToString()))
-                    {
-                        PlatformMapItem mapItem = PlatformMapCache[mapId.ToString()];
-                        if (mapItem != null)
-                        {
-                            platformMaps.Add(mapItem);
-                        }
-                    }
-                    else
-                    {
+
                     PlatformMapItem mapItem = BuildPlatformMapItem(row);
                     if (mapItem != null)
                     {
                         platformMaps.Add(mapItem);
                     }
                 }
-                }
 
                 platformMaps.Sort((x, y) => x.IGDBName.CompareTo(y.IGDBName));
 
+                //Database.DatabaseMemoryCache.SetCacheObject("PlatformMap", platformMaps, 600);
+
                 return platformMaps;
             }
         }
 
         public static PlatformMapItem GetPlatformMap(long Id)
-        {
-            if (PlatformMapCache.ContainsKey(Id.ToString()))
-            {
-                return PlatformMapCache[Id.ToString()];
-            }
-            else
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "SELECT * FROM PlatformMap WHERE Id = @Id";
@@ -156,10 +168,11 @@ namespace gaseous_server.Models
                 throw exception;
             }
         }
-        }
 
-        public static void WritePlatformMap(PlatformMapItem item, bool Update, bool AllowAvailableEmulatorOverwrite)
+        public static void WritePlatformMap(PlatformMapItem item, bool Update, bool AllowAvailableEmulatorOverwrite, bool overwriteBios = false)
         {
+            CreateDummyPlatform(item);
+
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
@@ -238,20 +251,36 @@ namespace gaseous_server.Models
             {
                 foreach (PlatformMapItem.EmulatorBiosItem biosItem in item.Bios)
                 {
-                    sql = "INSERT INTO PlatformMap_Bios (Id, Filename, Description, Hash) VALUES (@Id, @Filename, @Description, @Hash);";
+                    bool isEnabled = false;
+                    if (overwriteBios == true)
+                    {
+                        isEnabled = true;
+                    }
+                    else
+                    {
+                        if (item.EnabledBIOSHashes == null)
+                        {
+                            item.EnabledBIOSHashes = new List<string>();
+                        }
+                        if (item.EnabledBIOSHashes.Contains(biosItem.hash))
+                        {
+                            isEnabled = true;
+                        }
+                    }
+
+                    sql = "INSERT INTO PlatformMap_Bios (Id, Filename, Description, Hash, Enabled) VALUES (@Id, @Filename, @Description, @Hash, @Enabled);";
                     dbDict.Clear();
                     dbDict.Add("Id", item.IGDBId);
                     dbDict.Add("Filename", biosItem.filename);
                     dbDict.Add("Description", biosItem.description);
                     dbDict.Add("Hash", biosItem.hash);
+                    dbDict.Add("Enabled", isEnabled);
                     db.ExecuteCMD(sql, dbDict);
                 }
             }
 
-            if (PlatformMapCache.ContainsKey(item.IGDBId.ToString()))
-            {
-                PlatformMapCache.Remove(item.IGDBId.ToString());
-            }
+            // clear cache
+            Database.DatabaseMemoryCache.RemoveCacheObject("PlatformMap");
         }
 
         public static void WriteAvailableEmulators(PlatformMapItem item)
@@ -286,7 +315,16 @@ namespace gaseous_server.Models
             string sql = "";
 
             // get platform data
-            IGDB.Models.Platform? platform = Platforms.GetPlatform(IGDBId);
+            Platform? platform = null;
+            if (Storage.GetCacheStatus(HasheousClient.Models.MetadataSources.None, "Platform", IGDBId) == Storage.CacheStatus.NotPresent)
+            {
+                //platform = Platforms.GetPlatform(IGDBId, false);
+            }
+            else
+            {
+                // platform = (Platform)Storage.GetCacheValue<Platform>(HasheousClient.Models.MetadataSources.None, new Platform(), "id", IGDBId);
+                platform = Platforms.GetPlatform(IGDBId, HasheousClient.Models.MetadataSources.None);
+            }
 
             if (platform != null)
             {
@@ -352,6 +390,7 @@ namespace gaseous_server.Models
                 DataTable biosTable = db.ExecuteCMD(sql, dbDict);
 
                 List<PlatformMapItem.EmulatorBiosItem> bioss = new List<PlatformMapItem.EmulatorBiosItem>();
+                List<string> enabledBios = new List<string>();
                 foreach (DataRow biosRow in biosTable.Rows)
                 {
                     PlatformMapItem.EmulatorBiosItem bios = new PlatformMapItem.EmulatorBiosItem
@@ -361,6 +400,11 @@ namespace gaseous_server.Models
                         hash = ((string)Common.ReturnValueIfNull(biosRow["Hash"], "")).ToLower()
                     };
                     bioss.Add(bios);
+
+                    if ((bool)Common.ReturnValueIfNull(biosRow["Enabled"], true) == true)
+                    {
+                        enabledBios.Add(bios.hash);
+                    }
                 }
 
                 // build item
@@ -369,26 +413,20 @@ namespace gaseous_server.Models
                 mapItem.IGDBName = platform.Name;
                 mapItem.IGDBSlug = platform.Slug;
                 mapItem.AlternateNames = alternateNames;
-                mapItem.Extensions = new PlatformMapItem.FileExtensions{
+                mapItem.Extensions = new PlatformMapItem.FileExtensions
+                {
                     SupportedFileExtensions = knownExtensions,
                     UniqueFileExtensions = uniqueExtensions
                 };
                 mapItem.RetroPieDirectoryName = (string)Common.ReturnValueIfNull(row["RetroPieDirectoryName"], "");
-                mapItem.WebEmulator = new PlatformMapItem.WebEmulatorItem{
+                mapItem.WebEmulator = new PlatformMapItem.WebEmulatorItem
+                {
                     Type = (string)Common.ReturnValueIfNull(row["WebEmulator_Type"], ""),
                     Core = (string)Common.ReturnValueIfNull(row["WebEmulator_Core"], ""),
                     AvailableWebEmulators = Newtonsoft.Json.JsonConvert.DeserializeObject<List<PlatformMapItem.WebEmulatorItem.AvailableWebEmulatorItem>>((string)Common.ReturnValueIfNull(row["AvailableWebEmulators"], "[]"))
                 };
                 mapItem.Bios = bioss;
-                
-                if (PlatformMapCache.ContainsKey(IGDBId.ToString()))
-                {
-                    PlatformMapCache[IGDBId.ToString()] = mapItem;
-                }
-                else
-                {
-                    PlatformMapCache.Add(IGDBId.ToString(), mapItem);
-                }
+                mapItem.EnabledBIOSHashes = enabledBios;
 
                 return mapItem;
             }
@@ -414,8 +452,8 @@ namespace gaseous_server.Models
                         {
                             if (Signature.Game != null) { Signature.Game.System = PlatformMapping.IGDBName; }
                         }
-                        Signature.Flags.IGDBPlatformId = PlatformMapping.IGDBId;
-                        Signature.Flags.IGDBPlatformName = PlatformMapping.IGDBName;
+                        Signature.Flags.PlatformId = PlatformMapping.IGDBId;
+                        Signature.Flags.PlatformName = PlatformMapping.IGDBName;
 
                         PlatformFound = true;
 
@@ -438,8 +476,8 @@ namespace gaseous_server.Models
                         {
                             if (Signature.Game != null) { Signature.Game.System = PlatformMapping.IGDBName; }
                         }
-                        Signature.Flags.IGDBPlatformId = PlatformMapping.IGDBId;
-                        Signature.Flags.IGDBPlatformName = PlatformMapping.IGDBName;
+                        Signature.Flags.PlatformId = PlatformMapping.IGDBId;
+                        Signature.Flags.PlatformName = PlatformMapping.IGDBName;
 
                         PlatformFound = true;
 
@@ -455,6 +493,74 @@ namespace gaseous_server.Models
             }
         }
 
+        public PlatformMapItem GetUserPlatformMap(string UserId, long PlatformId, long GameId)
+        {
+            // get the system enabled bios hashes
+            Models.PlatformMapping.PlatformMapItem platformMapItem = PlatformMapping.GetPlatformMap(PlatformId);
+
+            // get the user enabled bios hashes
+            PlatformMapping.UserEmulatorConfiguration userEmulatorConfiguration = GetUserEmulator(UserId, GameId, PlatformId);
+            if (userEmulatorConfiguration != null)
+            {
+                platformMapItem.WebEmulator.Type = userEmulatorConfiguration.EmulatorType;
+                platformMapItem.WebEmulator.Core = userEmulatorConfiguration.Core;
+                platformMapItem.EnabledBIOSHashes = userEmulatorConfiguration.EnableBIOSFiles;
+            }
+
+            return platformMapItem;
+        }
+
+        public UserEmulatorConfiguration GetUserEmulator(string UserId, long GameId, long PlatformId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT Mapping FROM User_PlatformMap WHERE id = @UserId AND GameId = @GameId AND PlatformId = @PlatformId;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "UserId", UserId },
+                { "GameId", GameId },
+                { "PlatformId", PlatformId }
+            };
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count > 0)
+            {
+                UserEmulatorConfiguration emulator = Newtonsoft.Json.JsonConvert.DeserializeObject<UserEmulatorConfiguration>((string)data.Rows[0]["Mapping"]);
+
+                return emulator;
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        public void SetUserEmulator(string UserId, long GameId, long PlatformId, UserEmulatorConfiguration Mapping)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "INSERT INTO User_PlatformMap (id, GameId, PlatformId, Mapping) VALUES (@UserId, @GameId, @PlatformId, @Mapping) ON DUPLICATE KEY UPDATE Mapping = @Mapping;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "UserId", UserId },
+                { "GameId", GameId },
+                { "PlatformId", PlatformId },
+                { "Mapping", Newtonsoft.Json.JsonConvert.SerializeObject(Mapping) }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
+        public void DeleteUserEmulator(string UserId, long GameId, long PlatformId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM User_PlatformMap WHERE id = @UserId AND GameId = @GameId AND PlatformId = @PlatformId;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "UserId", UserId },
+                { "GameId", GameId },
+                { "PlatformId", PlatformId }
+            };
+            db.ExecuteCMD(sql, dbDict);
+        }
+
         public class PlatformMapItem
         {
             public long IGDBId { get; set; }
@@ -502,6 +608,15 @@ namespace gaseous_server.Models
                 public string description { get; set; }
                 public string filename { get; set; }
             }
+
+            public List<string> EnabledBIOSHashes { get; set; }
+        }
+
+        public class UserEmulatorConfiguration
+        {
+            public string EmulatorType { get; set; }
+            public string Core { get; set; }
+            public List<string> EnableBIOSFiles { get; set; } = new List<string>();
         }
     }
 }

gaseous-server/Models/Signatures_Games.cs

@@ -1,22 +1,365 @@
 using System;
 using System.Text.Json.Serialization;
+using gaseous_server.Classes;
+using gaseous_server.Classes.Metadata;
 using gaseous_signature_parser.models.RomSignatureObject;
+using HasheousClient.Models;
 
 namespace gaseous_server.Models
 {
-	public class Signatures_Games : HasheousClient.Models.LookupResponseModel
+    public class Signatures_Games : HasheousClient.Models.SignatureModel
     {
         public Signatures_Games()
         {
         }
 
-        public SignatureFlags Flags = new SignatureFlags();
+        [JsonIgnore]
+        public int Score
+        {
+            get
+            {
+                int _score = 0;
+
+                if (Game != null)
+                {
+                    _score = _score + Game.Score;
+                }
+
+                if (Rom != null)
+                {
+                    _score = _score + Rom.Score;
+                }
+
+                return _score;
+            }
+        }
+
+        public GameItem Game = new GameItem();
+        public RomItem Rom = new RomItem();
+
+        public SignatureFlags Flags
+        {
+            get
+            {
+                SignatureFlags _flags = new SignatureFlags();
+
+                foreach (SourceValues.SourceValueItem source in MetadataSources.Platforms)
+                {
+                    if (source.Source == Config.MetadataConfiguration.DefaultMetadataSource)
+                    {
+                        _flags.PlatformId = source.Id;
+                        _flags.PlatformName = source.Name;
+                        _flags.PlatformMetadataSource = source.Source;
+                        break;
+                    }
+                }
+
+                if (_flags.PlatformId == 0)
+                {
+                    // fall back to the IGDB source if present
+                    foreach (SourceValues.SourceValueItem source in MetadataSources.Platforms)
+                    {
+                        if (source.Source == HasheousClient.Models.MetadataSources.IGDB)
+                        {
+                            _flags.PlatformId = source.Id;
+                            _flags.PlatformName = source.Name;
+                            _flags.PlatformMetadataSource = source.Source;
+                            break;
+                        }
+                    }
+                }
+
+                foreach (SourceValues.SourceValueItem source in MetadataSources.Games)
+                {
+                    if (source.Source == Config.MetadataConfiguration.DefaultMetadataSource)
+                    {
+                        _flags.GameId = source.Id;
+                        _flags.GameName = source.Name;
+                        _flags.GameMetadataSource = source.Source;
+                        break;
+                    }
+                }
+
+                if (_flags.GameId == null || _flags.GameId == 0)
+                {
+                    _flags.GameId = 0;
+                    _flags.GameName = "Unknown Game";
+                    _flags.GameMetadataSource = HasheousClient.Models.MetadataSources.None;
+                }
+
+                return _flags;
+            }
+        }
+
+        public SourceValues MetadataSources = new SourceValues();
+
+        public class SourceValues
+        {
+            public List<SourceValueItem> Platforms = new List<SourceValueItem>();
+            public List<SourceValueItem> Games = new List<SourceValueItem>();
+
+            public class SourceValueItem
+            {
+                public long Id { get; set; }
+                public string Name { get; set; }
+                public HasheousClient.Models.MetadataSources Source { get; set; }
+            }
+
+            public void AddPlatform(long Id, string Name, HasheousClient.Models.MetadataSources Source)
+            {
+                // check that the platform doesn't already exist
+                foreach (SourceValueItem item in Platforms)
+                {
+                    if (item.Id == Id)
+                    {
+                        return;
+                    }
+                }
+
+                SourceValueItem newItem = new SourceValueItem();
+                newItem.Id = Id;
+                newItem.Name = Name;
+                newItem.Source = Source;
+                Platforms.Add(newItem);
+            }
+
+            public void AddGame(long Id, string Name, HasheousClient.Models.MetadataSources Source)
+            {
+                // check that the game doesn't already exist
+                foreach (SourceValueItem item in Games)
+                {
+                    if (item.Id == Id)
+                    {
+                        return;
+                    }
+                }
+
+                SourceValueItem newItem = new SourceValueItem();
+                newItem.Id = Id;
+                newItem.Name = Name;
+                newItem.Source = Source;
+                Games.Add(newItem);
+            }
+        }
 
         public class SignatureFlags
         {
-            public long IGDBPlatformId { get; set; }
-            public string IGDBPlatformName { get; set; }
-            public long IGDBGameId { get; set; }
+            public long PlatformId { get; set; }
+            public string PlatformName { get; set; }
+            public long GameId { get; set; }
+            public string GameName { get; set; }
+            public HasheousClient.Models.MetadataSources PlatformMetadataSource { get; set; }
+            public HasheousClient.Models.MetadataSources GameMetadataSource { get; set; }
+        }
+
+        public class GameItem : HasheousClient.Models.SignatureModel.GameItem
+        {
+            public GameItem()
+            {
+
+            }
+
+            public string UserManual { get; set; }
+
+            [JsonIgnore]
+            public int Score
+            {
+                get
+                {
+                    // calculate a score based on the availablility of data
+                    int _score = 0;
+                    var properties = this.GetType().GetProperties();
+                    foreach (var prop in properties)
+                    {
+                        if (prop.GetGetMethod() != null)
+                        {
+                            switch (prop.Name.ToLower())
+                            {
+                                case "id":
+                                case "score":
+                                    break;
+                                case "name":
+                                case "year":
+                                case "publisher":
+                                case "system":
+                                    if (prop.PropertyType == typeof(string))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 10;
+                                            }
+                                        }
+                                    }
+                                    break;
+                                default:
+                                    if (prop.PropertyType == typeof(string))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 1;
+                                            }
+                                        }
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+
+                    return _score;
+                }
+            }
+        }
+
+        public class RomItem : HasheousClient.Models.SignatureModel.RomItem
+        {
+            [JsonIgnore]
+            public int Score
+            {
+                get
+                {
+                    // calculate a score based on the availablility of data
+                    int _score = 0;
+                    var properties = this.GetType().GetProperties();
+                    foreach (var prop in properties)
+                    {
+                        if (prop.GetGetMethod() != null)
+                        {
+                            switch (prop.Name.ToLower())
+                            {
+                                case "name":
+                                case "size":
+                                case "crc":
+                                case "developmentstatus":
+                                case "flags":
+                                case "attributes":
+                                case "romtypemedia":
+                                case "medialabel":
+                                    if (prop.PropertyType == typeof(string) || prop.PropertyType == typeof(Int64) || prop.PropertyType == typeof(List<string>))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 10;
+                                            }
+                                        }
+                                    }
+                                    break;
+                                default:
+                                    if (prop.PropertyType == typeof(string))
+                                    {
+                                        if (prop.GetValue(this) != null)
+                                        {
+                                            string propVal = prop.GetValue(this).ToString();
+                                            if (propVal.Length > 0)
+                                            {
+                                                _score = _score + 1;
+                                            }
+                                        }
+                                    }
+                                    break;
+                            }
+                        }
+                    }
+
+                    return _score;
+                }
+            }
+
+            public class MediaType
+            {
+                public MediaType(SignatureSourceType Source, string MediaTypeString)
+                {
+                    switch (Source)
+                    {
+                        case RomItem.SignatureSourceType.TOSEC:
+                            string[] typeString = MediaTypeString.Split(" ");
+
+                            string inType = "";
+                            foreach (string typeStringVal in typeString)
+                            {
+                                if (inType == "")
+                                {
+                                    switch (typeStringVal.ToLower())
+                                    {
+                                        case "disk":
+                                            Media = RomItem.RomTypes.Disk;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "disc":
+                                            Media = RomItem.RomTypes.Disc;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "file":
+                                            Media = RomItem.RomTypes.File;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "part":
+                                            Media = RomItem.RomTypes.Part;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "tape":
+                                            Media = RomItem.RomTypes.Tape;
+
+                                            inType = typeStringVal;
+                                            break;
+                                        case "of":
+                                            inType = typeStringVal;
+                                            break;
+                                        case "side":
+                                            inType = typeStringVal;
+                                            break;
+                                    }
+                                }
+                                else
+                                {
+                                    switch (inType.ToLower())
+                                    {
+                                        case "disk":
+                                        case "disc":
+                                        case "file":
+                                        case "part":
+                                        case "tape":
+                                            Number = int.Parse(typeStringVal);
+                                            break;
+                                        case "of":
+                                            Count = int.Parse(typeStringVal);
+                                            break;
+                                        case "side":
+                                            Side = typeStringVal;
+                                            break;
+                                    }
+                                    inType = "";
+                                }
+                            }
+
+                            break;
+
+                        default:
+                            break;
+
+                    }
+                }
+
+                public RomItem.RomTypes? Media { get; set; }
+
+                public int? Number { get; set; }
+
+                public int? Count { get; set; }
+
+                public string? Side { get; set; }
+            }
         }
     }
 }

gaseous-server/Models/Signatures_Sources.cs

@@ -0,0 +1,20 @@
+using NuGet.Protocol.Core.Types;
+
+namespace gaseous_server.Models
+{
+    public class Signatures_Sources
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public string URL { get; set; }
+        public string Category { get; set; }
+        public string Version { get; set; }
+        public string Author { get; set; }
+        public string Email { get; set; }
+        public string Homepage { get; set; }
+        public gaseous_signature_parser.parser.SignatureParser SourceType { get; set; }
+        public string MD5 { get; set; }
+        public string SHA1 { get; set; }
+    }
+}

gaseous-server/Models/UserProfile.cs

@@ -0,0 +1,24 @@
+namespace gaseous_server.Models
+{
+    public class UserProfile
+    {
+        public Guid UserId { get; set; }
+        public string DisplayName { get; set; }
+        public string Quip { get; set; }
+        public NowPlayingItem? NowPlaying { get; set; }
+        public class NowPlayingItem
+        {
+            public Game Game { get; set; }
+            public HasheousClient.Models.Metadata.IGDB.Platform Platform { get; set; }
+            public long Duration { get; set; }
+        }
+        public ProfileImageItem? Avatar { get; set; }
+        public ProfileImageItem? ProfileBackground { get; set; }
+        public Dictionary<string, object> Data { get; set; }
+        public class ProfileImageItem
+        {
+            public string MimeType { get; set; }
+            public string Extension { get; set; }
+        }
+    }
+}

gaseous-server/ProcessQueue.cs

@@ -245,14 +245,32 @@ namespace gaseous_server
                                         CallingQueueItem = this
                                     };
 
-                                    Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing TOSEC files");
-                                    tIngest.Import(Path.Combine(Config.LibraryConfiguration.LibrarySignatureImportDirectory, "TOSEC"), gaseous_signature_parser.parser.SignatureParser.TOSEC);
+                                    foreach (int i in Enum.GetValues(typeof(gaseous_signature_parser.parser.SignatureParser)))
+                                    {
+                                        gaseous_signature_parser.parser.SignatureParser parserType = (gaseous_signature_parser.parser.SignatureParser)i;
+                                        if (
+                                            parserType != gaseous_signature_parser.parser.SignatureParser.Auto &&
+                                            parserType != gaseous_signature_parser.parser.SignatureParser.Unknown
+                                        )
+                                        {
+                                            Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing " + parserType + " files");
 
-                                    Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing MAME Arcade files");
-                                    tIngest.Import(Path.Combine(Config.LibraryConfiguration.LibrarySignatureImportDirectory, "MAME Arcade"), gaseous_signature_parser.parser.SignatureParser.MAMEArcade);
+                                            string SignaturePath = Path.Combine(Config.LibraryConfiguration.LibrarySignaturesDirectory, parserType.ToString());
+                                            string SignatureProcessedPath = Path.Combine(Config.LibraryConfiguration.LibrarySignaturesProcessedDirectory, parserType.ToString());
 
-                                    Logging.Log(Logging.LogType.Debug, "Signature Import", "Processing MAME MESS files");
-                                    tIngest.Import(Path.Combine(Config.LibraryConfiguration.LibrarySignatureImportDirectory, "MAME MESS"), gaseous_signature_parser.parser.SignatureParser.MAMEMess);
+                                            if (!Directory.Exists(SignaturePath))
+                                            {
+                                                Directory.CreateDirectory(SignaturePath);
+                                            }
+
+                                            if (!Directory.Exists(SignatureProcessedPath))
+                                            {
+                                                Directory.CreateDirectory(SignatureProcessedPath);
+                                            }
+
+                                            tIngest.Import(SignaturePath, SignatureProcessedPath, parserType);
+                                        }
+                                    }
 
                                     _SaveLastRunTime = true;
 
@@ -320,18 +338,6 @@ namespace gaseous_server
 
                                     break;
 
-                                case QueueItemType.Rematcher:
-                                    Logging.Log(Logging.LogType.Debug, "Timered Event", "Starting Rematch");
-                                    Classes.ImportGame importRematch = new ImportGame
-                                    {
-                                        CallingQueueItem = this
-                                    };
-                                    importRematch.Rematcher(_ForceExecute);
-
-                                    _SaveLastRunTime = true;
-
-                                    break;
-
                                 case QueueItemType.CollectionCompiler:
                                     Logging.Log(Logging.LogType.Debug, "Timered Event", "Starting Collection Compiler");
                                     Dictionary<string, object> collectionOptions = (Dictionary<string, object>)Options;
@@ -350,7 +356,8 @@ namespace gaseous_server
 
                                 case QueueItemType.DailyMaintainer:
                                     Logging.Log(Logging.LogType.Debug, "Timered Event", "Starting Daily Maintenance");
-                                    Classes.Maintenance maintenance = new Maintenance{
+                                    Classes.Maintenance maintenance = new Maintenance
+                                    {
                                         CallingQueueItem = this
                                     };
                                     maintenance.RunDailyMaintenance();
@@ -361,7 +368,8 @@ namespace gaseous_server
 
                                 case QueueItemType.WeeklyMaintainer:
                                     Logging.Log(Logging.LogType.Debug, "Timered Event", "Starting Weekly Maintenance");
-                                    Classes.Maintenance weeklyMaintenance = new Maintenance{
+                                    Classes.Maintenance weeklyMaintenance = new Maintenance
+                                    {
                                         CallingQueueItem = this
                                     };
                                     weeklyMaintenance.RunWeeklyMaintenance();
@@ -554,11 +562,6 @@ namespace gaseous_server
             /// </summary>
             LibraryScanWorker,
 
-            /// <summary>
-            /// Looks for roms in the library that have an unknown platform or game match
-            /// </summary>
-            Rematcher,
-
             /// <summary>
             /// Builds collections - set the options attribute to the id of the collection to build
             /// </summary>

gaseous-server/Program.cs

@@ -11,6 +11,7 @@ using Authentication;
 using Microsoft.AspNetCore.Identity;
 using gaseous_server.Classes.Metadata;
 using Asp.Versioning;
+using HasheousClient.Models.Metadata.IGDB;
 
 Logging.WriteToDiskOnly = true;
 Logging.Log(Logging.LogType.Information, "Startup", "Starting Gaseous Server " + Assembly.GetExecutingAssembly().GetName().Version);
@@ -36,6 +37,9 @@ db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.Conn
 
 // set up db
 db.InitDB();
+// create relation tables if they don't exist
+Storage.CreateRelationsTables<IGDB.Models.Game>();
+Storage.CreateRelationsTables<IGDB.Models.Platform>();
 
 // populate db with static data for lookups
 AgeRatings.PopulateAgeMap();
@@ -45,8 +49,11 @@ Config.InitSettings();
 // write updated settings back to the config file
 Config.UpdateConfig();
 
+// update default library path
+GameLibrary.UpdateDefaultLibraryPath();
+
 // set api metadata source from config
-Communications.MetadataSource = Config.MetadataConfiguration.MetadataSource;
+Communications.MetadataSource = Config.MetadataConfiguration.DefaultMetadataSource;
 
 // set up hasheous client
 HasheousClient.WebApp.HttpHelper.BaseUri = Config.MetadataConfiguration.HasheousHost;
@@ -64,13 +71,14 @@ if (Directory.Exists(Config.LibraryConfiguration.LibraryUploadDirectory))
 // kick off any delayed upgrade tasks
 // run 1002 background updates in the background on every start
 DatabaseMigration.BackgroundUpgradeTargetSchemaVersions.Add(1002);
+DatabaseMigration.BackgroundUpgradeTargetSchemaVersions.Add(1023);
 // start the task
 ProcessQueue.QueueItem queueItem = new ProcessQueue.QueueItem(
         ProcessQueue.QueueItemType.BackgroundDatabaseUpgrade,
         1,
         new List<ProcessQueue.QueueItemType>
         {
-            ProcessQueue.QueueItemType.All
+            ProcessQueue.QueueItemType.SignatureIngestor
         },
         false,
         true
@@ -319,86 +327,19 @@ app.Use(async (context, next) =>
     await next();
 });
 
-// emergency password recovery if environment variable is set
-// process:
-// - set the environment variable "recoveraccount" to the email address of the account to be recovered
-// - when the server starts the password will be reset to a random string and saved in the library
-//   directory with the name RecoverAccount.txt
-// - user should copy this password and remove the "recoveraccount" environment variable and the
-//   RecoverAccount.txt file
-// - the server will not start while the RecoverAccount.txt file exists
-string PasswordRecoveryFile = Path.Combine(Config.LibraryConfiguration.LibraryRootDirectory, "RecoverAccount.txt");
-if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("recoveraccount")))
-{   
-    if (File.Exists(PasswordRecoveryFile))
-    {
-        // password has already been set - do nothing and just exit
-        Logging.Log(Logging.LogType.Critical, "Server Startup", "Unable to start while recoveraccount environment varibale is set and RecoverAccount.txt file exists.", null, true);
-        Environment.Exit(0);
-    }
-    else
-    {
-        // generate and save the password to disk
-        int length = 10;
-        string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+";
-        var random = new Random();
-        string password = new string(Enumerable.Repeat(chars, length).Select(s => s[random.Next(s.Length)]).ToArray());
-
-        File.WriteAllText(PasswordRecoveryFile, password);
-        
-        // reset the password
-        using (var scope = app.Services.CreateScope())
-        {
-            var userManager = scope.ServiceProvider.GetRequiredService<UserStore>();
-            if (await userManager.FindByNameAsync(Environment.GetEnvironmentVariable("recoveraccount"), CancellationToken.None) != null)
-            {
-                ApplicationUser User = await userManager.FindByEmailAsync(Environment.GetEnvironmentVariable("recoveraccount"), CancellationToken.None);
-
-                //set user password
-                PasswordHasher<ApplicationUser> ph = new PasswordHasher<ApplicationUser>();
-                User.PasswordHash = ph.HashPassword(User, password);
-
-                await userManager.SetPasswordHashAsync(User, User.PasswordHash, CancellationToken.None);
-
-                Logging.Log(Logging.LogType.Information, "Server Startup", "Password reset complete, remove the recoveraccount environment variable and RecoverAccount.text file to allow server start.", null, true);
-
-                Environment.Exit(0);
-            }
-            else
-            {
-                Logging.Log(Logging.LogType.Critical, "Server Startup", "Account to recover not found.", null, true);
-
-                Environment.Exit(0);
-            }
-        }
-
-    }
-}
-else
-{
-    // check if RecoverAccount.text file is present
-    if (File.Exists(PasswordRecoveryFile))
-    {
-        // cannot start while password recovery file exists
-        Logging.Log(Logging.LogType.Critical, "Server Startup", "Unable to start while RecoverAccount.txt file exists. Remove the file and try again.", null, true);
-        Environment.Exit(0);
-    }
-}
-
 // setup library directories
 Config.LibraryConfiguration.InitLibrary();
 
-// insert unknown platform and game if not present
-gaseous_server.Classes.Metadata.Games.GetGame(0, false, false, false);
-gaseous_server.Classes.Metadata.Games.AssignAllGamesToPlatformIdZero();
-gaseous_server.Classes.Metadata.Platforms.GetPlatform(0);
-gaseous_server.Classes.Metadata.Platforms.AssignAllPlatformsToGameIdZero();
+// create unknown platform
+Platforms.GetPlatform(0, HasheousClient.Models.MetadataSources.None);
+Platforms.GetPlatform(0, HasheousClient.Models.MetadataSources.IGDB);
+Platforms.GetPlatform(0, HasheousClient.Models.MetadataSources.TheGamesDb);
 
 // extract platform map if not present
 PlatformMapping.ExtractPlatformMap();
 
-// force load platform map into cache
-var platformMap = PlatformMapping.PlatformMap;
+// migrate old firmware directory structure to new style
+Bios.MigrateToNewFolderStructure();
 
 // add background tasks
 ProcessQueue.QueueItems.Add(new ProcessQueue.QueueItem(
@@ -416,9 +357,6 @@ ProcessQueue.QueueItems.Add(new ProcessQueue.QueueItem(
 ProcessQueue.QueueItems.Add(new ProcessQueue.QueueItem(
     ProcessQueue.QueueItemType.LibraryScan)
     );
-ProcessQueue.QueueItems.Add(new ProcessQueue.QueueItem(
-    ProcessQueue.QueueItemType.Rematcher)
-    );
 
 // maintenance tasks
 ProcessQueue.QueueItem dailyMaintenance = new ProcessQueue.QueueItem(