Merge branch 'main' into dependabot/nuget/Magick.NET-Q8-AnyCPU-14.0.0

The CLI tool can be started from the root of the /App directory in the
container with the command:
`./gaseous-cli`

Running without arguments presents the following help screen:
```
Gaseous CLI - A tool for managing the Gaseous Server
Usage: gaseous-cli [command] [options]
Commands:
  user [command] [options] - Manage users
  role [command] [options] - Manage roles
  help - Display this help message
```

.devcontainer/Dockerfile

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

.devcontainer/devcontainer.json

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

.devcontainer/docker-compose.yml

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

.github/dependabot.yml

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

.github/release.yml

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

.github/workflows/BuildDockerOnTag-Prerelease.yml

@@ -9,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
+      - name: Login to GitHub Package Registry
-        uses: docker/build-push-action@v4
+        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: .
-          platforms: linux/amd64 #,linux/arm64
+          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
+      - name: Login to GitHub Package Registry
-        uses: docker/build-push-action@v4
+        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: .
-          platforms: linux/amd64 #,linux/arm64
+          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/BuildOnTestBranch.yml

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

.github/workflows/codeql.yml

@@ -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}}"

.github/workflows/dotnet.yml

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

.gitignore

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

.gitmodules

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

.vscode/launch.json

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

Dockerfile

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

Gaseous.sln

@@ -3,7 +3,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 25.0.1704.4
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-server", "gaseous-server\gaseous-server.csproj", "{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "gaseous-server", "gaseous-server\gaseous-server.csproj", "{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{17FA6F12-8532-420C-9489-CB8FDE42137C}"
 	ProjectSection(SolutionItems) = preProject
@@ -21,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
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B07A4655-A003-416B-A790-ADAA5B548E1A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{419CC4E4-8932-4E4A-B027-5521AA0CBA85}.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}.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
+                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+                       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
+  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works.
+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
+software for all its users.
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
 
   When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
@@ -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
+  Developers that use our General Public Licenses protect your rights
-these rights or asking you to surrender the rights.  Therefore, you have
+with two steps: (1) assert copyright on the software, and (2) offer
-certain responsibilities if you distribute copies of the software, or if
+you this License which gives you legal permission to copy, distribute
-you modify it: responsibilities to respect the freedom of others.
+and/or modify the software.
 
-  For example, if you distribute copies of such a program, whether
+  A secondary benefit of defending all users' freedom is that
-gratis or for a fee, you must pass on to the recipients the same
+improvements made in alternate versions of the program, if they
-freedoms that you received.  You must make sure that they, too, receive
+receive widespread use, become available for other developers to
-or can get the source code.  And you must show them these terms so they
+incorporate.  Many developers of free software are heartened and
-know their rights.
+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:
+  The GNU Affero General Public License is designed specifically to
-(1) assert copyright on the software, and (2) offer you this License
+ensure that, in such cases, the modified source code becomes available
-giving you legal permission to copy, distribute and/or modify it.
+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
+  An older license, called the Affero General Public License and
-that there is no warranty for this free software.  For both users' and
+published by Affero, was designed to accomplish similar goals.  This is
-authors' sake, the GPL requires that modified versions be marked as
+a different license, not a version of the Affero GPL, but Affero has
-changed, so that their problems will not be attributed erroneously to
+released a new version of the Affero GPL which permits relicensing under
-authors of previous versions.
+this license.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
@@ -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,
+but the work with which it is combined will remain governed by version
-section 13, concerning interaction through a network will apply to the
+3 of the GNU General Public License.
-combination as such.
 
   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
+the GNU Affero General Public License from time to time.  Such new versions
-be similar in spirit to the present version, but may differ in detail to
+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
+    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) 2023  Gaseous
+    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
+    it under the terms of the GNU Affero General Public License as published
-    the Free Software Foundation, either version 3 of the License, or
+    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
+  If your software can interact with users remotely through a computer
-notice like this when it starts in an interactive mode:
+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
-    <program>  Copyright (C) 2023  Gaseous
+interface could display a "Source" link that leads users to an archive
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+of the code.  There are many ways you could offer source, and different
-    This is free software, and you are welcome to redistribute it
+solutions will be better for different programs; see section 13 for the
-    under certain conditions; type `show c' for details.
+specific requirements.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
 
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU 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,194 +1,53 @@
+[![.NET](https://github.com/gaseous-project/gaseous-server/actions/workflows/dotnet.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/dotnet.yml) [![CodeQL](https://github.com/gaseous-project/gaseous-server/actions/workflows/codeql.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/codeql.yml) [![Build Release Docker Image](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildDockerOnTag-Release.yml/badge.svg)](https://github.com/gaseous-project/gaseous-server/actions/workflows/BuildDockerOnTag-Release.yml)
 # Gaseous Server
 
-This is the server for the Gaseous system. It offers ROM and title management, as well as some basic in browser emulation of those ROM's.
+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
 
-This project is currently not suitable for being exposed to the internet.
+Versions 1.6.1 and earlier are not suitable for being exposed to the internet, as:
-1. there is currently no authentication support, meaning anyone could trash your library
+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 the server to the internet, **you do so at your own risk**.
+If you expose one of these earlier versions of the server to the internet, **you do so at your own risk**.
+
+Version 1.7.0 and later contain user authentication, and can be exposed to the internet. However, it is recommended to no expose the server to the internet if you're not actively using it remotely, or if you have alternative means to access it remotely like a VPN.
+
+While we do our best to stay on top of server security, if you expose the server to the internet **you do so at your own risk**.
 
 ## Screenshots
-![Library](./screenshots/Library.png)
+![Library](./gaseous-server/wwwroot/screenshots/Library.png)
-![Game](./screenshots/Game.png)
+![Game](./gaseous-server/wwwroot/screenshots/Game.png)
-![Emulator](./screenshots/Emulator.png)
+![Emulator](./gaseous-server/wwwroot/screenshots/Emulator.png)
+
 
 ## Requirements
-* MariaDB 11.1.2 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.
-  * Currently MariaDB is the preferred database server, while MySQL will continue to be supported for existing users (they should be interchangable).
+  * 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.
+
+## Friends of Gaseous
+* [EmulatorJS](https://github.com/EmulatorJS/EmulatorJS): A fantastic (and fast) Javascript based implementation of RetroArch, supporting a wide variety of platforms. Discord: https://discord.gg/6akryGkETU
+* [RomM](https://github.com/zurdi15/romm): Another self hosted ROM manager. Discord: https://discord.gg/P5HtHnhUDH
+
 ## Third Party Projects
 The following projects are used by Gaseous
-* https://dotnet.microsoft.com/en-us/apps/aspnet
+* [ASP.NET](https://dotnet.microsoft.com/en-us/apps/aspnet)
-* https://github.com/JamesNK/Newtonsoft.Json
+* [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json)
-* https://www.nuget.org/packages/MySql.Data/8.0.32.1
+* [MySQLConnector](https://mysqlconnector.net)
-* https://github.com/kamranayub/igdb-dotnet
+* [IGDB-DOTNET](https://github.com/kamranayub/igdb-dotnet)
-* https://github.com/EmulatorJS/EmulatorJS
+* [EmulatorJS](https://github.com/EmulatorJS/EmulatorJS)
 
 ## Discord Server
 [![Join our Discord server!](https://invite.casperiv.dev/?inviteCode=Nhu7wpT3k4&format=svg)](https://discord.gg/Nhu7wpT3k4)
 
-# Setup
+# Installation
-
+See https://github.com/gaseous-project/gaseous-server/wiki/Installation for installation instructions.
-## Configuration File
-When Gaseous-Server is started for the first time, it creates a configuration file at ~/.gaseous-server/config.json if it doesn't exist. Some values can be filled in using environment variables (such as in the case of using docker).
-
-### DatabaseConfiguration
-| Attribute | Environment Variable |
-| --------- | -------------------- |
-| HostName  | dbhost               |
-| UserName  | dbuser               |
-| Password  | dbpass               |
-
-### IGDBConfiguration
-| Attribute | Environment Variable |
-| --------- | -------------------- |
-| ClientId  | igdbclientid         |
-| Secret.   | igdbclientsecret     |
-
-### config.json
-```json
-{
-  "DatabaseConfiguration": {
-    "HostName": "localhost",
-    "UserName": "gaseous",
-    "Password": "gaseous",
-    "DatabaseName": "gaseous",
-    "Port": 3306
-  },
-  "IGDBConfiguration": {
-    "ClientId": "<clientid>",
-    "Secret": "<secret>"
-  },
-  "LoggingConfiguration": {
-    "DebugLogging": false,
-    "LogRetention": 7
-  }
-}
-
-```
-
-## Docker
-### Deploy with the prebuilt Docker image
-Dockerfile and docker-compose.yml files have been provided to make deployment of the server as easy as possible.
-1. Download the docker-compose-{database}.yml file for the database type you would like to use.
-2. Open the docker-compose.yml file and edit the igdbclientid and igdbclientsecret to the values retrieved from your IGDB account
-3. Run the command ```docker-compose up -d```
-4. Connect to the host on port 5198
-
-### Build and deploy a Docker image from source
-Dockerfile and docker-compose-build.yml files have been provided to make deployment of the server as easy as possible.
-1. Clone the repo with ```git clone https://github.com/gaseous-project/gaseous-server.git```
-2. Change into the gaseous-server directory
-3. Clone the submodules with the command ```git submodule update --init```
-4. Open the docker-compose-{database}-build.yml file and edit the igdbclientid and igdbclientsecret to the values retrieved from your IGDB account
-5. Run the command ```docker-compose --file docker-compose-{database}-build.yml up -d```
-6. Connect to the host on port 5198
-
-## Source
-### Build and deploy
-1. Install and configure a MariaDB or MySQL instance - this is beyond the scope of this document
-2. Install the dotnet 7.0 packages appropriate for your operating system
-    * See: https://learn.microsoft.com/en-us/dotnet/core/install/linux
-3. Create a database user with permission to create a databse. Gaseous will create the new database and apply the database schema on it's first startup.
-4. Clone the repo with ```git clone https://github.com/gaseous-project/gaseous-server.git```
-5. Change into the gaseous-server directory
-6. As the main branch is the development branch, you might want to change to a stable version - these are tagged with a version number. For example to change to the 1.5.0 release, use the command ```git checkout v1.5.0```
-    * Check the releases page for the version you would like to run: https://github.com/gaseous-project/gaseous-server/releases
-7. Clone the submodules with the command ```git submodule update --init --recursive```
-    * This command will clone the code that the server uses from other projects (currently only EmulatorJS)
-8. Create a directory in the home directory of the user that will run the server. For example, if running as the user ```gaseous```, create the directory ```/home/gaseous/.gaseous-server```
-9. Change into the ```.gaseous-server``` directory created in the previous step
-10. Copy the JSON from the config file above into a new file named ```config.json```
-11. Update the database section with the database server hostname, username, password, and port
-12. Compile the server by changing back to the repo cloned earlier and executing:
-    * ```dotnet restore "gaseous-server/gaseous-server.csproj"```
-    * ```dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained false -c Release -o <output directory>```
-    * replace ```<output directory>``` with the directory of your choosing. The compiled application will be copied there. For this example we'll use ```/opt/gaseous-server```
-13. The server can then be started by executing ```dotnet /opt/gaseous-server/gaseous-server.dll```
-    * If you would like the server to run on a different ip address and port (for example 0.0.0.0:8080), add the --urls argument: ```dotnet /opt/gaseous-server/gaseous-server.dll --urls http://0.0.0.0:8080```
-
-**Note**: The above instructions were tested on macOS Ventura, and Ubuntu 22.04.3. There was a report that Debian 11 had an issue with the git submodule commands (see: https://github.com/gaseous-project/gaseous-server/issues/71). This was possibly due to an older git package.
-
-If the git submodule commands aren't working, you can:
-1. change to the ```gaseous-server/wwwroot/emulators``` directory
-2. delete the ```EmulatorJS``` directory
-3. clone the EmulatorJS repository with ```git clone https://github.com/EmulatorJS/EmulatorJS.git```
-
-### Updating from source
-1. Stop the server
-2. Switch to the source directory
-3. Update your repo:
-    * If running from the main branch, run ```git pull``` to update the repo
-    * If running from another branch or tag, run:
-      * ```git fetch```
-      * ```git checkout <branch or tag name>```
-4. Update the submodules with ```git submodule update --recursive```
-5. Run steps 12 and 13 from the above Build guide
 
 # Adding Content
-While games can be added to the server without them, it is recommended adding some signature DAT files beforehand to allow for better matching of ROMs to games.
+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
-These signature DAT files contain a list of titles with hashes for many of the ROM images that have been found by the community.
-
-Currently supported DAT's:
-* TOSEC: https://www.tosecdev.org/downloads/category/56-2023-01-23
-* MAME Arcade and MAME Mess: https://www.progettosnaps.net/dats/MAME
-
-If there are other DAT's you'd like to see support for, please raise an issue with a link to the DAT's.
-
-## Adding signature DAT files
-### TOSEC
-1. Download the DAT files from the source website. For example; from https://www.tosecdev.org/downloads/category/56-2023-01-23
-2. Extract the archive
-3. Copy the DAT files to ~/.gaseous-server/Data/Signatures/TOSEC/
-
-### MAME Arcade
-1. Download the DAT files from the source website. For example; from https://www.progettosnaps.net/dats/MAME
-2. Extract the archive
-3. Copy the file name "MAME 0.257 (arcade).dat" files to ~/.gaseous-server/Data/Signatures/MAME Arcade/
-
-### MAME MESS
-1. Download the DAT files from the source website. For example; from https://www.progettosnaps.net/dats/MAME
-2. Extract the archive
-3. Copy the file name "MAME 0.257 (mess).dat" files to ~/.gaseous-server/Data/Signatures/MAME MESS/
-
-# Adding Game Images
-1. Files can be presented as either stand alone files, or as zip files - currently 7z is unsupported.
-2. Name the file appropriately.
-   * Attempting a search for the game name on https://www.igdb.com can help with file naming. If a hash search is unsuccessful, Gaseous will fall back to attempting to search by the file name.
-3. Add the file to the server:
-   * Click the Upload button in the top right of the main Gaseous web page, and drag the files into the modal. The files will be uploaded and analyzed.
-   * Copy the file to ~/.gaseous-server/Data/Import
-
-# Game Image Title Matching
-Image to game matching follows the following order of operations, stopping the process at the first match:
-### Get the file signature
-1. Attempt a hash search
-2. Attempt to search the signature database for a rom matching the file name - sometimes the hash can not be matched as a highscore table for example was saved to the image
-3. Attempt to parse the file name - clues such as the extension being used to define which platform the file belongs to are used to create a search criteria
-
-**Note**: If the file being scanned is a zip, the file will be extracted and searched. The first file whose signature can be found will be used to match the entire zip archive - be sure that the zip only contains files related to one game.
-
-### Create a list of search candidates
-Before beginning, remove any version numbers, and anything in the search string that is between ()
-1. Add the full name of the image
-2. Add the name of the image with any " - " replaced by ": "
-3. Add the name of the image with text after a " - " removed
-4. Add the name of the image with text after a ": " removed
-
-### Search IGDB for a game match
-Loop through each of the search candidates searching using:
-1. "where" - exact match as the search candidate
-2. "wherefuzzy" - partial match using wildcards
-3. "search" - uses a more flexible search method
-4. "searchNoPlatform" - uses the "search" method, but does not constrain the search to the determined platform
-
-**Note**: If more than one result is found, the seach will loop through the returned results:
-* If an exact (case-insensitive) match is found, that result is used for the match
-* If still no match, the image will be set as "Unknown" as there is no way for Gaseous to know which title is the correct one.

build/Dockerfile

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

build/Dockerfile-EmbeddedDB

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

build/embeddeddb/entrypoint.sh

@@ -0,0 +1,18 @@
+#!/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/.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,13 @@
+#!/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/.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,8 +13,9 @@ services:
     ports:
       - 5198:80
     volumes:
-      - gs:/root/.gaseous-server
+      - gs:/home/gaseous/.gaseous-server
     environment:
+      - TZ=Australia/Sydney
       - dbhost=gsdb
       - dbuser=root
       - dbpass=gaseous

docker-compose-mysql-build.yml

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

docker-compose-mysql.yml

@@ -1,38 +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:
-      - dbhost=gsdb
-      - dbuser=root
-      - dbpass=gaseous
-      - igdbclientid=<clientid>
-      - igdbclientsecret=<clientsecret>
-  gsdb:
-    container_name: gsdb
-    image: mysql:8
-    restart: unless-stopped
-    networks:
-      - gaseous
-    volumes:
-      - gsdb:/var/lib/mysql
-    environment:
-      - MYSQL_ROOT_PASSWORD=gaseous
-      - MYSQL_USER=gaseous
-      - MYSQL_PASSWORD=gaseous
-networks:
-  gaseous:
-    driver: bridge
-volumes:
-  gs:
-  gsdb:

docker-compose.yml

@@ -11,8 +11,9 @@ services:
     ports:
       - 5198:80
     volumes:
-      - gs:/root/.gaseous-server
+      - gs:/home/gaseous/.gaseous-server
     environment:
+      - TZ=Australia/Sydney
       - dbhost=gsdb
       - dbuser=root
       - dbpass=gaseous

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

@@ -11,5 +11,7 @@ namespace Authentication
     public class ApplicationUser : IdentityUser
     {
         public SecurityProfileViewModel SecurityProfile { get; set; }
+        public List<UserPreferenceViewModel> UserPreferences { get; set; }
+        public Guid ProfileId { get; set; }
     }
 }

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

@@ -75,7 +75,7 @@ namespace Authentication
         public TUser GetUserById(string userId)
         {
             TUser user = null;
-            string commandText = "Select * from Users 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);
@@ -99,6 +99,8 @@ namespace Authentication
                 user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
                 user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
                 user.SecurityProfile = GetSecurityProfile(user);
+                user.UserPreferences = GetPreferences(user);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
             }
 
             return user;
@@ -112,7 +114,7 @@ namespace Authentication
         public List<TUser> GetUserByName(string normalizedUserName)
         {
             List<TUser> users = new List<TUser>();
-            string commandText = "Select * from Users 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);
@@ -135,6 +137,8 @@ namespace Authentication
                 user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
                 user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
                 user.SecurityProfile = GetSecurityProfile(user);
+                user.UserPreferences = GetPreferences(user);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
                 users.Add(user);
             }
 
@@ -144,7 +148,7 @@ namespace Authentication
         public List<TUser> GetUsers()
         {
             List<TUser> users = new List<TUser>();
-            string commandText = "Select * from Users 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)
@@ -166,6 +170,8 @@ namespace Authentication
                 user.AccessFailedCount = string.IsNullOrEmpty((string?)row["AccessFailedCount"]) ? 0 : int.Parse((string?)row["AccessFailedCount"]);
                 user.TwoFactorEnabled = row["TwoFactorEnabled"] == "1" ? true : false;
                 user.SecurityProfile = GetSecurityProfile(user);
+                user.UserPreferences = GetPreferences(user);
+                user.ProfileId = string.IsNullOrEmpty((string?)row["ProfileId"]) ? Guid.Empty : Guid.Parse((string?)row["ProfileId"]);
                 users.Add(user);
             }
 
@@ -252,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);
@@ -273,6 +280,9 @@ namespace Authentication
             // set default security profile
             SetSecurityProfile(user, new SecurityProfileViewModel());
 
+            // set default preferences
+            SetPreferences(user, new List<UserPreferenceViewModel>());
+
             return _database.ExecuteCMD(commandText, parameters).Rows.Count;
         }
 
@@ -283,7 +293,7 @@ namespace Authentication
         /// <returns></returns>
         private int Delete(string userId)
         {
-            string commandText = "Delete from Users where Id = @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);
 
@@ -328,6 +338,9 @@ namespace Authentication
             // set the security profile
             SetSecurityProfile(user, user.SecurityProfile);
 
+            // set preferences
+            SetPreferences(user, user.UserPreferences);
+
             return _database.ExecuteCMD(commandText, parameters).Rows.Count;
         }
 
@@ -367,5 +380,91 @@ namespace Authentication
 
             return _database.ExecuteCMD(commandText, parameters).Rows.Count;
         }
+
+        public List<UserPreferenceViewModel> GetPreferences(TUser user)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT `Setting`, `Value` FROM User_Settings WHERE Id=@id;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("id", user.Id);
+
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            List<UserPreferenceViewModel> userPrefs = new List<UserPreferenceViewModel>();
+            foreach (DataRow row in data.Rows)
+            {
+                UserPreferenceViewModel userPref = new UserPreferenceViewModel();
+                userPref.Setting = (string)row["Setting"];
+                userPref.Value = (string)row["Value"];
+                userPrefs.Add(userPref);
+            }
+
+            return userPrefs;
+        }
+
+        public int SetPreferences(TUser user, List<UserPreferenceViewModel> model)
+        {
+            if (model != null)
+            {
+                List<UserPreferenceViewModel> userPreferences = GetPreferences(user);
+
+                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+
+                foreach (UserPreferenceViewModel modelItem in model)
+                {
+                    bool prefItemFound = false;
+                    foreach (UserPreferenceViewModel existing in userPreferences)
+                    {
+                        if (existing.Setting.ToLower() == modelItem.Setting.ToLower())
+                        {
+                            prefItemFound = true;
+                            break;
+                        }
+                    }
+
+                    string sql = "INSERT INTO User_Settings (`Id`, `Setting`, `Value`) VALUES (@id, @setting, @value);";
+                    if (prefItemFound == true)
+                    {
+                        sql = "UPDATE User_Settings SET `Value`=@value WHERE `Id`=@id AND `Setting`=@setting";
+                    }
+                    Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                    dbDict.Add("id", user.Id);
+                    dbDict.Add("setting", modelItem.Setting);
+                    dbDict.Add("value", modelItem.Value);
+                    db.ExecuteNonQuery(sql, dbDict);
+                }
+
+                return model.Count;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
+        public Guid SetAvatar(TUser user, byte[] bytes)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql;
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "userid", user.Id }
+            };
+
+            if (bytes.Length == 0)
+            {
+                sql = "DELETE FROM UserAvatars WHERE UserId = @userid";
+                db.ExecuteNonQuery(sql, dbDict);
+                return Guid.Empty;
+            }
+            else
+            {
+                sql = "DELETE FROM UserAvatars WHERE UserId = @userid; INSERT INTO UserAvatars (UserId, Id, Avatar) VALUES (@userid, @id, @avatar);";
+                dbDict.Add("id", Guid.NewGuid());
+                dbDict.Add("avatar", bytes);
+                db.ExecuteNonQuery(sql, dbDict);
+                return (Guid)dbDict["id"];
+            }
+        }
     }
 }

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

@@ -7,7 +7,10 @@ namespace Authentication
         public string EmailAddress { get; set; }
         public List<String> Roles { get; set; }
         public SecurityProfileViewModel SecurityProfile { get; set; }
-        public string HighestRole {
+        public List<UserPreferenceViewModel> UserPreferences { get; set; }
+        public Guid ProfileId { get; set; }
+        public string HighestRole
+        {
             get
             {
                 string _highestRole = "";

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

@@ -5,13 +5,13 @@ namespace Authentication
     public class SecurityProfileViewModel
     {
         public AgeRestrictionItem AgeRestrictionPolicy { get; set; } = new AgeRestrictionItem{ 
-            MaximumAgeRestriction = "Adult",
+            MaximumAgeRestriction = gaseous_server.Classes.Metadata.AgeGroups.AgeRestrictionGroupings.Adult,
             IncludeUnrated = true 
         };
 
         public class AgeRestrictionItem
         {
-            public string MaximumAgeRestriction { get; set; }
+            public gaseous_server.Classes.Metadata.AgeGroups.AgeRestrictionGroupings MaximumAgeRestriction { get; set; }
             public bool IncludeUnrated { get; set; }
         }
     }

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

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

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

@@ -8,10 +8,14 @@ namespace Authentication
         public DateTimeOffset? LockoutEnd { get; set; }
         public List<string> Roles { get; set; }
         public SecurityProfileViewModel SecurityProfile { 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)
@@ -39,6 +43,11 @@ namespace Authentication
                                 break;
                         }
                     }
+                }
+                else
+                {
+                    _highestRole = "Player";
+                }
 
                 return _highestRole;
             }

gaseous-server/Classes/Collections.cs

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

gaseous-server/Classes/Common.cs

@@ -1,9 +1,13 @@
-using System;
+using System.Collections.Concurrent;
+using System.ComponentModel;
+using System.Data;
+using System.IO.Compression;
+using System.Reflection;
 using System.Security.Cryptography;
 
 namespace gaseous_server.Classes
 {
-	public class Common
+	public static class Common
 	{
 		/// <summary>
 		/// Returns IfNullValue if the ObjectToCheck is null
@@ -16,7 +20,8 @@ namespace gaseous_server.Classes
 			if (ObjectToCheck == null || ObjectToCheck == System.DBNull.Value)
 			{
 				return IfNullValue;
-			} else
+			}
+			else
 			{
 				return ObjectToCheck;
 			}
@@ -40,11 +45,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);
@@ -110,6 +117,116 @@ namespace gaseous_server.Classes
 			return Path.GetFullPath(new Uri(path).LocalPath)
 					.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
 		}
+
+		public static string GetDescription(this Enum value)
+		{
+			return ((DescriptionAttribute)Attribute.GetCustomAttribute(
+				value.GetType().GetFields(BindingFlags.Public | BindingFlags.Static)
+					.Single(x => x.GetValue(null).Equals(value)),
+				typeof(DescriptionAttribute)))?.Description ?? value.ToString();
+		}
+
+		// compression
+		public static byte[] Compress(byte[] data)
+		{
+			MemoryStream output = new MemoryStream();
+			using (DeflateStream dstream = new DeflateStream(output, CompressionLevel.Optimal))
+			{
+				dstream.Write(data, 0, data.Length);
+			}
+			return output.ToArray();
+		}
+
+		public static byte[] Decompress(byte[] data)
+		{
+			MemoryStream input = new MemoryStream(data);
+			MemoryStream output = new MemoryStream();
+			using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
+			{
+				dstream.CopyTo(output);
+			}
+			return output.ToArray();
+		}
+
+		public static object GetEnvVar(string envName, string defaultValue)
+		{
+			if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable(envName)))
+			{
+				return Environment.GetEnvironmentVariable(envName);
+			}
+			else
+			{
+				return defaultValue;
 			}
 		}
 
+		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>
+	/// Provides a way to set contextual data that flows with the call and 
+	/// async context of a test or invocation.
+	/// </summary>
+	public static class CallContext
+	{
+		static ConcurrentDictionary<string, AsyncLocal<object>> state = new ConcurrentDictionary<string, AsyncLocal<object>>();
+
+		/// <summary>
+		/// Stores a given object and associates it with the specified name.
+		/// </summary>
+		/// <param name="name">The name with which to associate the new item in the call context.</param>
+		/// <param name="data">The object to store in the call context.</param>
+		public static void SetData(string name, object data) =>
+			state.GetOrAdd(name, _ => new AsyncLocal<object>()).Value = data;
+
+		/// <summary>
+		/// Retrieves an object with the specified name from the <see cref="CallContext"/>.
+		/// </summary>
+		/// <param name="name">The name of the item in the call context.</param>
+		/// <returns>The object in the call context associated with the specified name, or <see langword="null"/> if not found.</returns>
+		public static object GetData(string name) =>
+			state.TryGetValue(name, out AsyncLocal<object> data) ? data.Value : null;
+	}
+}

gaseous-server/Classes/Config.cs

@@ -2,6 +2,8 @@
 using System.Data;
 using Newtonsoft.Json;
 using IGDB.Models;
+using gaseous_server.Classes.Metadata;
+using NuGet.Common;
 
 namespace gaseous_server.Classes
 {
@@ -57,6 +59,14 @@ namespace gaseous_server.Classes
             }
         }
 
+        public static ConfigFile.MetadataAPI MetadataConfiguration
+        {
+            get
+            {
+                return _config.MetadataConfiguration;
+            }
+        }
+
         public static ConfigFile.IGDB IGDB
         {
             get
@@ -70,7 +80,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;
@@ -108,11 +119,33 @@ namespace gaseous_server.Classes
                     if (_tempConfig != null)
                     {
                         _config = _tempConfig;
-                    } else
+
+                        // load environment variables if we're in a docker container
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("INDOCKER")))
+                        {
+                            if (Environment.GetEnvironmentVariable("INDOCKER") == "1")
+                            {
+                                Console.WriteLine("Running in Docker - setting configuration from variables");
+                                _config.DatabaseConfiguration.HostName = (string)Common.GetEnvVar("dbhost", _config.DatabaseConfiguration.HostName);
+                                _config.DatabaseConfiguration.UserName = (string)Common.GetEnvVar("dbuser", _config.DatabaseConfiguration.UserName);
+                                _config.DatabaseConfiguration.Password = (string)Common.GetEnvVar("dbpass", _config.DatabaseConfiguration.Password);
+                                _config.DatabaseConfiguration.DatabaseName = (string)Common.GetEnvVar("dbname", _config.DatabaseConfiguration.DatabaseName);
+                                _config.DatabaseConfiguration.Port = int.Parse((string)Common.GetEnvVar("dbport", _config.DatabaseConfiguration.Port.ToString()));
+                                _config.MetadataConfiguration.MetadataSource = (HasheousClient.Models.MetadataModel.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.MetadataSources), (string)Common.GetEnvVar("metadatasource", _config.MetadataConfiguration.MetadataSource.ToString()));
+                                _config.MetadataConfiguration.SignatureSource = (HasheousClient.Models.MetadataModel.SignatureSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.SignatureSources), (string)Common.GetEnvVar("signaturesource", _config.MetadataConfiguration.SignatureSource.ToString())); ;
+                                _config.MetadataConfiguration.MaxLibraryScanWorkers = int.Parse((string)Common.GetEnvVar("maxlibraryscanworkers", _config.MetadataConfiguration.MaxLibraryScanWorkers.ToString()));
+                                _config.MetadataConfiguration.HasheousHost = (string)Common.GetEnvVar("hasheoushost", _config.MetadataConfiguration.HasheousHost);
+                                _config.IGDBConfiguration.ClientId = (string)Common.GetEnvVar("igdbclientid", _config.IGDBConfiguration.ClientId);
+                                _config.IGDBConfiguration.Secret = (string)Common.GetEnvVar("igdbclientsecret", _config.IGDBConfiguration.Secret);
+                            }
+                        }
+                    }
+                    else
                     {
                         throw new Exception("There was an error reading the config file: Json returned null");
                     }
-                } else
+                }
+                else
                 {
                     // no config file!
                     // use defaults and save
@@ -121,8 +154,8 @@ namespace gaseous_server.Classes
                 }
             }
 
-            Console.WriteLine("Using configuration:");
+            // Console.WriteLine("Using configuration:");
-            Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(_config, Formatting.Indented));
+            // Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(_config, Formatting.Indented));
         }
 
         public static void UpdateConfig()
@@ -152,7 +185,7 @@ namespace gaseous_server.Classes
             File.WriteAllText(ConfigurationFilePath, configRaw);
         }
 
-        private static Dictionary<string, string> AppSettings = new Dictionary<string, string>();
+        private static Dictionary<string, object> AppSettings = new Dictionary<string, object>();
 
         public static void InitSettings()
         {
@@ -162,45 +195,122 @@ namespace gaseous_server.Classes
             DataTable dbResponse = db.ExecuteCMD(sql);
             foreach (DataRow dataRow in dbResponse.Rows)
             {
-                if (AppSettings.ContainsKey((string)dataRow["Setting"]))
+                string SettingName = (string)dataRow["Setting"];
+
+                if (AppSettings.ContainsKey(SettingName))
                 {
-                    AppSettings[(string)dataRow["Setting"]] = (string)dataRow["Value"];
+                    AppSettings.Remove(SettingName);
+                }
+
+                // Logging.Log(Logging.LogType.Information, "Load Settings", "Loading setting " + SettingName + " from database");
+
+                try
+                {
+                    if (Database.schema_version >= 1016)
+                    {
+                        switch ((int)dataRow["ValueType"])
+                        {
+                            case 0:
+                            default:
+                                // value is a string
+                                AppSettings.Add(SettingName, dataRow["Value"]);
+                                break;
+
+                            case 1:
+                                // value is a datetime
+                                AppSettings.Add(SettingName, dataRow["ValueDate"]);
+                                break;
+                        }
                     }
                     else
                     {
-                    AppSettings.Add((string)dataRow["Setting"], (string)dataRow["Value"]);
+                        AppSettings.Add(SettingName, dataRow["Value"]);
+                    }
+                }
+                catch (InvalidCastException castEx)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Settings", "Exception when reading server setting " + SettingName + ". Resetting to default.", castEx);
+
+                    // delete broken setting and return the default
+                    // this error is probably generated during an upgrade
+                    sql = "DELETE FROM Settings WHERE Setting = @SettingName";
+                    Dictionary<string, object> dbDict = new Dictionary<string, object>
+                    {
+                        { "SettingName", SettingName }
+                    };
+                }
+                catch (Exception ex)
+                {
+                    Logging.Log(Logging.LogType.Critical, "Settings", "Exception when reading server setting " + SettingName + ".", ex);
                 }
             }
         }
 
-        public static string ReadSetting(string SettingName, string DefaultValue)
+        public static T ReadSetting<T>(string SettingName, T DefaultValue)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            try
             {
                 if (AppSettings.ContainsKey(SettingName))
                 {
-                return AppSettings[SettingName];
+                    return (T)AppSettings[SettingName];
                 }
                 else
                 {
-                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                    string sql;
-                string sql = "SELECT Value FROM Settings WHERE Setting = @SettingName";
+                    Dictionary<string, object> dbDict = new Dictionary<string, object>
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                    {
-                dbDict.Add("SettingName", SettingName);
+                        { "SettingName", SettingName }
-                dbDict.Add("Value", DefaultValue);
+                    };
+                    DataTable dbResponse;
 
                     try
                     {
                         Logging.Log(Logging.LogType.Debug, "Database", "Reading setting '" + SettingName + "'");
-                    DataTable dbResponse = db.ExecuteCMD(sql, dbDict);
+
+                        if (Database.schema_version >= 1016)
+                        {
+                            sql = "SELECT Value, ValueDate FROM Settings WHERE Setting = @SettingName";
+
+                            dbResponse = db.ExecuteCMD(sql, dbDict);
+                            Type type = typeof(T);
                             if (dbResponse.Rows.Count == 0)
                             {
                                 // no value with that name stored - respond with the default value
-                        SetSetting(SettingName, DefaultValue);
+                                SetSetting<T>(SettingName, DefaultValue);
                                 return DefaultValue;
                             }
                             else
                             {
-                        AppSettings.Add(SettingName, (string)dbResponse.Rows[0][0]);
+                                if (type.ToString() == "System.DateTime")
-                        return (string)dbResponse.Rows[0][0];
+                                {
+                                    AppSettings.Add(SettingName, (T)dbResponse.Rows[0]["ValueDate"]);
+                                    return (T)dbResponse.Rows[0]["ValueDate"];
+                                }
+                                else
+                                {
+                                    AppSettings.Add(SettingName, (T)dbResponse.Rows[0]["Value"]);
+                                    return (T)dbResponse.Rows[0]["Value"];
+                                }
+                            }
+                        }
+                        else
+                        {
+                            sql = "SELECT Value FROM Settings WHERE Setting = @SettingName";
+
+                            dbResponse = db.ExecuteCMD(sql, dbDict);
+                            Type type = typeof(T);
+                            if (dbResponse.Rows.Count == 0)
+                            {
+                                // no value with that name stored - respond with the default value
+                                SetSetting<T>(SettingName, DefaultValue);
+                                return DefaultValue;
+                            }
+                            else
+                            {
+                                AppSettings.Add(SettingName, (T)dbResponse.Rows[0]["Value"]);
+                                return (T)dbResponse.Rows[0]["Value"];
+                            }
                         }
                     }
                     catch (Exception ex)
@@ -210,14 +320,72 @@ namespace gaseous_server.Classes
                     }
                 }
             }
+            catch (InvalidCastException castEx)
+            {
+                Logging.Log(Logging.LogType.Warning, "Settings", "Exception when reading server setting " + SettingName + ". Resetting to default.", castEx);
 
-        public static void SetSetting(string SettingName, string Value)
+                // delete broken setting and return the default
+                // this error is probably generated during an upgrade
+                if (AppSettings.ContainsKey(SettingName))
+                {
+                    AppSettings.Remove(SettingName);
+                }
+
+                string sql = "DELETE FROM Settings WHERE Setting = @SettingName";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>
+                {
+                    { "SettingName", SettingName }
+                };
+
+                return DefaultValue;
+            }
+            catch (Exception ex)
+            {
+                Logging.Log(Logging.LogType.Critical, "Settings", "Exception when reading server setting " + SettingName + ".", ex);
+                throw;
+            }
+        }
+
+        public static void SetSetting<T>(string SettingName, T Value)
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "REPLACE INTO Settings (Setting, Value) VALUES (@SettingName, @Value)";
+            string sql;
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            Dictionary<string, object> dbDict;
-            dbDict.Add("SettingName", SettingName);
+
-            dbDict.Add("Value", Value);
+            if (Database.schema_version >= 1016)
+            {
+                sql = "REPLACE INTO Settings (Setting, ValueType, Value, ValueDate) VALUES (@SettingName, @ValueType, @Value, @ValueDate)";
+                Type type = typeof(T);
+                if (type.ToString() == "System.DateTime")
+                {
+                    dbDict = new Dictionary<string, object>
+                    {
+                        { "SettingName", SettingName },
+                        { "ValueType", 1 },
+                        { "Value", null },
+                        { "ValueDate", Value }
+                    };
+                }
+                else
+                {
+                    dbDict = new Dictionary<string, object>
+                    {
+                        { "SettingName", SettingName },
+                        { "ValueType", 0 },
+                        { "Value", Value },
+                        { "ValueDate", null }
+                    };
+                }
+            }
+            else
+            {
+                sql = "REPLACE INTO Settings (Setting, Value) VALUES (@SettingName, @Value)";
+                dbDict = new Dictionary<string, object>
+                {
+                    { "SettingName", SettingName },
+                    { "Value", Value }
+                };
+            }
 
             Logging.Log(Logging.LogType.Debug, "Database", "Storing setting '" + SettingName + "' to value: '" + Value + "'");
             try
@@ -247,13 +415,16 @@ namespace gaseous_server.Classes
             [JsonIgnore]
             public Library LibraryConfiguration = new Library();
 
+            public MetadataAPI MetadataConfiguration = new MetadataAPI();
+
             public IGDB IGDBConfiguration = new IGDB();
 
             public Logging LoggingConfiguration = new Logging();
 
             public class Database
             {
-                private static string _DefaultHostName {
+                private static string _DefaultHostName
+                {
                     get
                     {
                         if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbhost")))
@@ -297,11 +468,41 @@ namespace gaseous_server.Classes
                     }
                 }
 
+                private static string _DefaultDatabaseName
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbname")))
+                        {
+                            return Environment.GetEnvironmentVariable("dbname");
+                        }
+                        else
+                        {
+                            return "gaseous";
+                        }
+                    }
+                }
+
+                private static int _DefaultDatabasePort
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("dbport")))
+                        {
+                            return int.Parse(Environment.GetEnvironmentVariable("dbport"));
+                        }
+                        else
+                        {
+                            return 3306;
+                        }
+                    }
+                }
+
                 public string HostName = _DefaultHostName;
                 public string UserName = _DefaultUserName;
                 public string Password = _DefaultPassword;
-                public string DatabaseName = "gaseous";
+                public string DatabaseName = _DefaultDatabaseName;
-                public int Port = 3306;
+                public int Port = _DefaultDatabasePort;
 
                 [JsonIgnore]
                 public string ConnectionString
@@ -330,11 +531,11 @@ namespace gaseous_server.Classes
                 {
                     get
                     {
-                        return ReadSetting("LibraryRootDirectory", Path.Combine(Config.ConfigurationPath, "Data"));
+                        return ReadSetting<string>("LibraryRootDirectory", Path.Combine(Config.ConfigurationPath, "Data"));
                     }
                     set
                     {
-                        SetSetting("LibraryRootDirectory", value);
+                        SetSetting<string>("LibraryRootDirectory", value);
                     }
                 }
 
@@ -439,7 +640,7 @@ namespace gaseous_server.Classes
                     return MetadataPath;
                 }
 
-                public string LibrarySignatureImportDirectory
+                public string LibrarySignaturesDirectory
                 {
                     get
                     {
@@ -447,6 +648,14 @@ namespace gaseous_server.Classes
                     }
                 }
 
+                public string LibrarySignaturesProcessedDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryRootDirectory, "Signatures - Processed");
+                    }
+                }
+
                 public void InitLibrary()
                 {
                     if (!Directory.Exists(LibraryRootDirectory)) { Directory.CreateDirectory(LibraryRootDirectory); }
@@ -456,10 +665,90 @@ namespace gaseous_server.Classes
                     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
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("metadatasource")))
+                        {
+                            return (HasheousClient.Models.MetadataModel.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.MetadataSources), Environment.GetEnvironmentVariable("metadatasource"));
+                        }
+                        else
+                        {
+                            return HasheousClient.Models.MetadataModel.MetadataSources.IGDB;
+                        }
+                    }
+                }
+
+                private static HasheousClient.Models.MetadataModel.SignatureSources _SignatureSource
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("signaturesource")))
+                        {
+                            return (HasheousClient.Models.MetadataModel.SignatureSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.SignatureSources), Environment.GetEnvironmentVariable("signaturesource"));
+                        }
+                        else
+                        {
+                            return HasheousClient.Models.MetadataModel.SignatureSources.LocalOnly;
+                        }
+                    }
+                }
+
+                private static bool _HasheousSubmitFixes { get; set; } = false;
+
+                private static string _HasheousAPIKey { get; set; } = "";
+
+                private static int _MaxLibraryScanWorkers
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("maxlibraryscanworkers")))
+                        {
+                            return int.Parse(Environment.GetEnvironmentVariable("maxlibraryscanworkers"));
+                        }
+                        else
+                        {
+                            return 4;
+                        }
+                    }
+                }
+
+                private static string _HasheousHost
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("hasheoushost")))
+                        {
+                            return Environment.GetEnvironmentVariable("hasheoushost");
+                        }
+                        else
+                        {
+                            return "https://hasheous.org/";
+                        }
+                    }
+                }
+
+                public HasheousClient.Models.MetadataModel.MetadataSources MetadataSource = _MetadataSource;
+
+                public HasheousClient.Models.MetadataModel.SignatureSources SignatureSource = _SignatureSource;
+
+                public bool HasheousSubmitFixes = _HasheousSubmitFixes;
+
+                public string HasheousAPIKey = _HasheousAPIKey;
+
+                public int MaxLibraryScanWorkers = _MaxLibraryScanWorkers;
+
+                public string HasheousHost = _HasheousHost;
+            }
+
             public class IGDB
             {
                 private static string _DefaultIGDBClientId
@@ -503,11 +792,7 @@ namespace gaseous_server.Classes
                 // log retention in days
                 public int LogRetention = 7;
 
-                public enum LoggingFormat
+                public bool AlwaysLogToDisk = false;
-                {
-                    Json,
-                    Text
-                }
             }
         }
     }

gaseous-server/Classes/Database.cs

@@ -9,6 +9,21 @@ namespace gaseous_server.Classes
 {
 	public class Database
 	{
+		private static int _schema_version { get; set; } = 0;
+		public static int schema_version
+		{
+			get
+			{
+				//Logging.Log(Logging.LogType.Information, "Database Schema", "Schema version is " + _schema_version);
+				return _schema_version;
+			}
+			set
+			{
+				//Logging.Log(Logging.LogType.Information, "Database Schema", "Setting schema version " + _schema_version);
+				_schema_version = value;
+			}
+		}
+
 		public Database()
 		{
 
@@ -58,6 +73,8 @@ namespace gaseous_server.Classes
 			// load resources
 			var assembly = Assembly.GetExecutingAssembly();
 
+			DatabaseMemoryCacheOptions? CacheOptions = new DatabaseMemoryCacheOptions(false);
+
 			switch (_ConnectorType)
 			{
 				case databaseType.MySql:
@@ -65,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 = "";
@@ -94,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?
@@ -105,22 +131,35 @@ 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
 										{
 											// run pre-upgrade code
 											DatabaseMigration.PreUpgradeScript(i, _ConnectorType);
 
 											// apply schema!
 											Logging.Log(Logging.LogType.Information, "Database", "Updating schema to version " + i);
-                                        ExecuteCMD(dbScript, dbDict);
+											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);
+
+											// update schema version variable
+											Database.schema_version = i;
+										}
+										catch (Exception ex)
+										{
+											Logging.Log(Logging.LogType.Critical, "Database", "Schema upgrade failed! Unable to continue.", ex);
+											System.Environment.Exit(1);
+										}
 									}
 								}
 							}
@@ -133,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?>>();
@@ -191,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();
 			}
@@ -227,7 +341,8 @@ namespace gaseous_server.Classes
 			{
 				case databaseType.MySql:
 					MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
-                    return (int)conn.ExecNonQuery(Command, Parameters, Timeout);
+					int retVal = conn.ExecNonQuery(Command, Parameters, Timeout);
+					return retVal;
 				default:
 					return 0;
 			}
@@ -256,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)
@@ -321,7 +578,8 @@ namespace gaseous_server.Classes
 				DataTable RetTable = new DataTable();
 
 				Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
-                MySqlConnection conn = new MySqlConnection(DBConn);
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
+				{
 					conn.Open();
 
 					MySqlCommand cmd = new MySqlCommand
@@ -345,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());
@@ -353,6 +613,7 @@ namespace gaseous_server.Classes
 
 					Logging.Log(Logging.LogType.Debug, "Database", "Closing database connection", null, true);
 					conn.Close();
+				}
 
 				return RetTable;
 			}
@@ -362,7 +623,8 @@ namespace gaseous_server.Classes
 				int result = 0;
 
 				Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
-                MySqlConnection conn = new MySqlConnection(DBConn);
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
+				{
 					conn.Open();
 
 					MySqlCommand cmd = new MySqlCommand
@@ -386,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());
@@ -394,13 +658,15 @@ namespace gaseous_server.Classes
 
 					Logging.Log(Logging.LogType.Debug, "Database", "Closing database connection", null, true);
 					conn.Close();
+				}
 
 				return result;
 			}
 
 			public void TransactionExecCMD(List<Dictionary<string, object>> Parameters, int Timeout)
 			{
-                var conn = new MySqlConnection(DBConn);
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
+				{
 					conn.Open();
 					var command = conn.CreateCommand();
 					MySqlTransaction transaction;
@@ -417,6 +683,7 @@ namespace gaseous_server.Classes
 					transaction.Commit();
 					conn.Close();
 				}
+			}
 
 			private MySqlCommand buildcommand(MySqlConnection Conn, string SQL, Dictionary<string, object> Parameters, int Timeout)
 			{
@@ -441,7 +708,8 @@ namespace gaseous_server.Classes
 
 			public bool TestConnection()
 			{
-				MySqlConnection conn = new MySqlConnection(DBConn);
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
+				{
 					try
 					{
 						conn.Open();
@@ -456,4 +724,5 @@ namespace gaseous_server.Classes
 			}
 		}
 	}
+}
 

gaseous-server/Classes/DatabaseMigration.cs

@@ -1,5 +1,9 @@
 using System;
 using System.Data;
+using System.Reflection;
+using gaseous_server.Classes.Metadata;
+using gaseous_server.Models;
+using IGDB.Models;
 
 namespace gaseous_server.Classes
 {
@@ -9,13 +13,66 @@ namespace gaseous_server.Classes
 
         public static void PreUpgradeScript(int TargetSchemaVersion, Database.databaseType? DatabaseType)
         {
+            // load resources
+            var assembly = Assembly.GetExecutingAssembly();
 
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            DataTable data;
+
+            Logging.Log(Logging.LogType.Information, "Database", "Checking for pre-upgrade for schema version " + TargetSchemaVersion);
+
+            switch (DatabaseType)
+            {
+                case Database.databaseType.MySql:
+                    switch (TargetSchemaVersion)
+                    {
+                        case 1005:
+                            Logging.Log(Logging.LogType.Information, "Database", "Running pre-upgrade for schema version " + TargetSchemaVersion);
+
+                            // there was a mistake at dbschema version 1004-1005
+                            // the first preview release of v1.7 reused dbschema version 1004
+                            // if table "Relation_Game_AgeRatings" exists - then we need to apply the gaseous-fix-1005.sql script before applying the standard 1005 script
+                            sql = "SELECT table_name FROM information_schema.tables WHERE table_schema = @dbname AND table_name = @tablename;";
+                            dbDict.Add("dbname", Config.DatabaseConfiguration.DatabaseName);
+                            dbDict.Add("tablename", "Relation_Game_AgeRatings");
+                            data = db.ExecuteCMD(sql, dbDict);
+                            if (data.Rows.Count == 0)
+                            {
+                                Logging.Log(Logging.LogType.Information, "Database", "Schema version " + TargetSchemaVersion + " requires a table which is missing.");
+
+                                string resourceName = "gaseous_server.Support.Database.MySQL.gaseous-fix-1005.sql";
+                                string dbScript = "";
+
+                                string[] resources = Assembly.GetExecutingAssembly().GetManifestResourceNames();
+                                if (resources.Contains(resourceName))
+                                {
+                                    using (Stream stream = assembly.GetManifestResourceStream(resourceName))
+                                    using (StreamReader reader = new StreamReader(stream))
+                                    {
+                                        dbScript = reader.ReadToEnd();
+
+                                        // apply schema!
+                                        Logging.Log(Logging.LogType.Information, "Database", "Applying schema version fix prior to version 1005");
+                                        db.ExecuteCMD(dbScript, dbDict, 180);
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                    break;
+            }
         }
 
         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>();
+            DataTable data;
 
             switch (DatabaseType)
             {
@@ -32,12 +89,12 @@ namespace gaseous_server.Classes
 
                             // copy root path to new libraries format
                             string oldRoot = Path.Combine(Config.LibraryConfiguration.LibraryRootDirectory, "Library");
-                            string sql = "INSERT INTO GameLibraries (Name, Path, DefaultLibrary, DefaultPlatform) VALUES (@name, @path, @defaultlibrary, @defaultplatform); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+                            sql = "INSERT INTO GameLibraries (Name, Path, DefaultLibrary, DefaultPlatform) VALUES (@name, @path, @defaultlibrary, @defaultplatform); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                             dbDict.Add("name", "Default");
                             dbDict.Add("path", oldRoot);
                             dbDict.Add("defaultlibrary", 1);
                             dbDict.Add("defaultplatform", 0);
-                            DataTable data = db.ExecuteCMD(sql, dbDict);
+                            data = db.ExecuteCMD(sql, dbDict);
 
                             // apply the new library id to the existing roms
                             sql = "UPDATE Games_Roms SET LibraryId=@libraryid;";
@@ -46,6 +103,85 @@ namespace gaseous_server.Classes
                             db.ExecuteCMD(sql, dbDict);
                             break;
 
+                        case 1016:
+                            // delete old format LastRun_* settings from settings table
+                            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);
+                            }
+
+                            // this is a safe background task
+                            BackgroundUpgradeTargetSchemaVersions.Add(1023);
+                            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);
+                            }
+                            break;
                     }
                     break;
             }
@@ -60,11 +196,16 @@ namespace gaseous_server.Classes
                     case 1002:
                         MySql_1002_MigrateMetadataVersion();
                         break;
+
+                    case 1023:
+                        MySql_1023_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>();
@@ -159,5 +300,39 @@ namespace gaseous_server.Classes
                 }
             }
         }
+
+        public static void MySql_1023_MigrateMetadataVersion()
+        {
+            FileSignature fileSignature = new FileSignature();
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM 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"]
+                );
+
+                Platform platform = Platforms.GetPlatform((long)row["PlatformId"], false);
+                Game game = Games.GetGame((long)row["GameId"], false, false, false);
+
+                ImportGame.StoreROM(library, hash, game, platform, signature, (string)row["Path"], (long)row["Id"]);
+
+                count += 1;
+            }
+        }
     }
 }

gaseous-server/Classes/Favourites.cs

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

gaseous-server/Classes/FileSignature.cs

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

gaseous-server/Classes/Filters.cs

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

gaseous-server/Classes/GameLibrary.cs

@@ -34,6 +34,12 @@ namespace gaseous_server
             { }
         }
 
+        public class CannotDeleteLibraryWhileScanIsActive : Exception
+        {
+            public CannotDeleteLibraryWhileScanIsActive() : base("Unable to delete library while a library scan is active. Wait for all scans to complete and try again")
+            { }
+        }
+
         // code
         public static LibraryItem GetDefaultLibrary
         {
@@ -45,6 +51,11 @@ namespace gaseous_server
                 DataRow row = data.Rows[0];
                 LibraryItem library = new LibraryItem((int)row["Id"], (string)row["Name"], (string)row["Path"], (long)row["DefaultPlatform"], Convert.ToBoolean((int)row["DefaultLibrary"]));
 
+                if (!Directory.Exists(library.Path))
+                {
+                    Directory.CreateDirectory(library.Path);
+                }
+
                 return library;
             }
         }
@@ -55,12 +66,21 @@ namespace gaseous_server
             {
                 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)
                 {
                     LibraryItem library = new LibraryItem((int)row["Id"], (string)row["Name"], (string)row["Path"], (long)row["DefaultPlatform"], Convert.ToBoolean((int)row["DefaultLibrary"]));
                     libraryItems.Add(library);
+
+                    if (library.IsDefaultLibrary == true)
+                    {
+                        // check directory exists
+                        if (!Directory.Exists(library.Path))
+                        {
+                            Directory.CreateDirectory(library.Path);
+                        }
+                    }
                 }
 
                 return libraryItems;
@@ -96,21 +116,42 @@ namespace gaseous_server
 
             int newLibraryId = (int)(long)data.Rows[0][0];
 
-            return GetLibrary(newLibraryId);
+            Logging.Log(Logging.LogType.Information, "Library Management", "Created library " + Name + " at directory " + PathName);
+
+            LibraryItem library = GetLibrary(newLibraryId);
+
+            return library;
         }
 
         public static void DeleteLibrary(int LibraryId)
         {
-            if (GetLibrary(LibraryId).IsDefaultLibrary == false)
+            LibraryItem library = GetLibrary(LibraryId);
+            if (library.IsDefaultLibrary == false)
             {
+                // check for active library scans
+                foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+                {
+                    if (
+                        (item.ItemType == ProcessQueue.QueueItemType.LibraryScan && item.ItemState == ProcessQueue.QueueItemState.Running) ||
+                        (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker && item.ItemState == ProcessQueue.QueueItemState.Running)
+                    )
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Library Management", "Unable to delete libraries while a library scan is running. Wait until the the library scan is completed and try again.");
+                        throw new CannotDeleteLibraryWhileScanIsActive();
+                    }
+                }
+
                 Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
                 string sql = "DELETE FROM Games_Roms WHERE LibraryId=@id; DELETE FROM GameLibraries WHERE Id=@id;";
                 Dictionary<string, object> dbDict = new Dictionary<string, object>();
                 dbDict.Add("id", LibraryId);
                 db.ExecuteCMD(sql, dbDict);
+
+                Logging.Log(Logging.LogType.Information, "Library Management", "Deleted library " + library.Name + " at path " + library.Path);
             }
             else
             {
+                Logging.Log(Logging.LogType.Warning, "Library Management", "Unable to delete the default library.");
                 throw new CannotDeleteDefaultLibrary();
             }
         }
@@ -134,6 +175,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)
@@ -143,6 +202,11 @@ namespace gaseous_server
                 _Path = Path;
                 _DefaultPlatformId = DefaultPlatformId;
                 _IsDefaultLibrary = IsDefaultLibrary;
+
+                if (!Directory.Exists(Path))
+                {
+                    Directory.CreateDirectory(Path);
+                }
             }
 
             int _Id = 0;

gaseous-server/Classes/ImportGames.cs

@@ -1,34 +1,44 @@
 using System;
 using System.Data;
 using System.IO.Compression;
+using System.Security.Authentication;
 using System.Security.Policy;
 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;
 
 namespace gaseous_server.Classes
 {
-	public class ImportGames
+    public class ImportGame : QueueItemStatus
     {
-		public ImportGames(string ImportPath)
+        public void ProcessDirectory(string ImportPath)
         {
             if (Directory.Exists(ImportPath))
             {
-				string[] importContents_Files = Directory.GetFiles(ImportPath);
+                string[] importContents = Directory.GetFiles(ImportPath, "*.*", SearchOption.AllDirectories);
-                string[] importContents_Directories = Directory.GetDirectories(ImportPath);
+
+                Logging.Log(Logging.LogType.Information, "Import Games", "Found " + importContents.Length + " files to process in import directory: " + ImportPath);
 
                 // import files first
-				foreach (string importContent in importContents_Files) {
+                int importCount = 1;
-					ImportGame.ImportGameFile(importContent, null);
+                foreach (string importContent in importContents)
-				}
+                {
+                    SetStatus(importCount, importContents.Length, "Importing file: " + importContent);
 
-                // import sub directories
+                    ImportGameFile(importContent, null);
-                foreach (string importDir in importContents_Directories) {
+
-                    Classes.ImportGames importGames = new Classes.ImportGames(importDir);
+                    importCount += 1;
                 }
+                ClearStatus();
+
+                DeleteOrphanedDirectories(ImportPath);
             }
             else
             {
@@ -37,13 +47,11 @@ namespace gaseous_server.Classes
             }
         }
 
-
+        public Dictionary<string, object> ImportGameFile(string GameFileImportPath, IGDB.Models.Platform? OverridePlatform)
-	}
-
-	public class ImportGame
-	{
-        public static void ImportGameFile(string GameFileImportPath, IGDB.Models.Platform? OverridePlatform)
         {
+            Dictionary<string, object> RetVal = new Dictionary<string, object>();
+            RetVal.Add("path", Path.GetFileName(GameFileImportPath));
+
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
@@ -62,6 +70,8 @@ namespace gaseous_server.Classes
                 if (IsBios == null)
                 {
                     // file is a rom
+                    RetVal.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);
@@ -89,12 +99,15 @@ namespace gaseous_server.Classes
                         {
                             Logging.Log(Logging.LogType.Warning, "Import Game", "  " + GameFileImportPath + " already in database - skipping import");
                         }
+
+                        RetVal.Add("status", "duplicate");
                     }
                     else
                     {
                         Logging.Log(Logging.LogType.Information, "Import Game", "  " + GameFileImportPath + " not in database - processing");
 
-                        Models.Signatures_Games discoveredSignature = GetFileSignature(hash, fi, GameFileImportPath);
+                        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;
@@ -113,20 +126,30 @@ namespace gaseous_server.Classes
                             discoveredSignature.Flags.IGDBPlatformName = determinedPlatform.Name;
                         }
 
-                        IGDB.Models.Game determinedGame = SearchForGame(discoveredSignature.Game.Name, discoveredSignature.Flags.IGDBPlatformId);
+                        IGDB.Models.Game determinedGame = SearchForGame(discoveredSignature, discoveredSignature.Flags.IGDBPlatformId, true);
 
                         // add to database
-                        StoreROM(GameLibrary.GetDefaultLibrary, hash, determinedGame, determinedPlatform, discoveredSignature, GameFileImportPath);
+                        long RomId = StoreROM(GameLibrary.GetDefaultLibrary, hash, determinedGame, determinedPlatform, discoveredSignature, GameFileImportPath);
+
+                        // build return value
+                        RetVal.Add("romid", RomId);
+                        RetVal.Add("platform", determinedPlatform);
+                        RetVal.Add("game", determinedGame);
+                        RetVal.Add("signature", discoveredSignature);
+                        RetVal.Add("status", "imported");
                     }
                 }
                 else
                 {
                     // file is a bios
-                    if (IsBios.WebEmulator != null)
+                    RetVal.Add("type", "bios");
-                    {
+                    RetVal.Add("status", "notimported");
+
                     foreach (Classes.Bios.BiosItem biosItem in Classes.Bios.GetBios())
                     {
-                            if (biosItem.Available == false && biosItem.hash == hash.md5hash)
+                        if (biosItem.Available == false)
+                        {
+                            if (biosItem.hash == hash.md5hash)
                             {
                                 string biosPath = biosItem.biosPath.Replace(biosItem.filename, "");
                                 if (!Directory.Exists(biosPath))
@@ -136,163 +159,51 @@ namespace gaseous_server.Classes
 
                                 File.Move(GameFileImportPath, biosItem.biosPath, true);
 
-                                break;
+                                RetVal.Add("name", biosItem.filename);
+                                RetVal.Add("platform", Platforms.GetPlatform(biosItem.platformid, false, false));
+                                RetVal["status"] = "imported";
+
+                                return RetVal;
                             }
                         }
+                        else
+                        {
+                            if (biosItem.hash == hash.md5hash)
+                            {
+                                RetVal["status"] = "duplicate";
+                                return RetVal;
+                            }
                         }
                     }
                 }
             }
 
-        public static Models.Signatures_Games GetFileSignature(Common.hashObject hash, FileInfo fi, string GameFileImportPath)
+            return RetVal;
-        {
+        }
-            Models.Signatures_Games discoveredSignature = _GetFileSignature(hash, fi, GameFileImportPath);
 
-            if ((Path.GetExtension(GameFileImportPath) == ".zip") && (fi.Length < 1073741824))
+        public static IGDB.Models.Game SearchForGame(gaseous_server.Models.Signatures_Games Signature, long PlatformId, bool FullDownload)
         {
-                // file is a zip and less than 1 GiB
+            if (Signature.Flags != null)
-                // extract the zip file and search the contents
+            {
-                string ExtractPath = Path.Combine(Config.LibraryConfiguration.LibraryTempDirectory, Path.GetRandomFileName());
+                if (Signature.Flags.IGDBGameId != null && Signature.Flags.IGDBGameId != 0)
-                if (!Directory.Exists(ExtractPath)) { Directory.CreateDirectory(ExtractPath); }
+                {
+                    // game was determined elsewhere - probably a Hasheous server
                     try
                     {
-                    ZipFile.ExtractToDirectory(GameFileImportPath, ExtractPath);
+                        return Games.GetGame(Signature.Flags.IGDBGameId, false, false, FullDownload);
-
-                    // loop through contents until we find the first signature match
-                    foreach (string file in Directory.GetFiles(ExtractPath))
-                    {
-                        FileInfo zfi = new FileInfo(file);
-                        Common.hashObject zhash = new Common.hashObject(file);
-
-                        Models.Signatures_Games zDiscoveredSignature = _GetFileSignature(zhash, zfi, file);
-                        zDiscoveredSignature.Rom.Name = Path.ChangeExtension(zDiscoveredSignature.Rom.Name, ".zip");
-
-                        if (zDiscoveredSignature.Score > discoveredSignature.Score)
-                        {
-                            if (
-                                zDiscoveredSignature.Rom.SignatureSource == gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType.MAMEArcade || 
-                                zDiscoveredSignature.Rom.SignatureSource == gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType.MAMEMess
-                            )
-                            {
-                                zDiscoveredSignature.Rom.Name = zDiscoveredSignature.Game.Description + ".zip";
-                            }
-                            zDiscoveredSignature.Rom.Crc = discoveredSignature.Rom.Crc;
-                            zDiscoveredSignature.Rom.Md5 = discoveredSignature.Rom.Md5;
-                            zDiscoveredSignature.Rom.Sha1 = discoveredSignature.Rom.Sha1;
-                            zDiscoveredSignature.Rom.Size = discoveredSignature.Rom.Size;
-                            discoveredSignature = zDiscoveredSignature;
-
-                            break;
-                        }
-                    }
                     }
                     catch (Exception ex)
                     {
-                    Logging.Log(Logging.LogType.Critical, "Get Signature", "Error processing zip file: " + GameFileImportPath, ex);
+                        Logging.Log(Logging.LogType.Warning, "Import Game", "Provided game id resulted in a failed game lookup", ex);
                     }
-
-                if (Directory.Exists(ExtractPath)) { Directory.Delete(ExtractPath, true); }
-            }
-
-            return discoveredSignature;
-        }
-
-		private static Models.Signatures_Games _GetFileSignature(Common.hashObject hash, FileInfo fi, string GameFileImportPath)
-		{
-            // check 1: do we have a signature for it?
-            gaseous_server.Controllers.SignaturesController sc = new Controllers.SignaturesController();
-            List<Models.Signatures_Games> signatures = sc.GetSignature(hash.md5hash);
-            if (signatures.Count == 0)
-            {
-                // no md5 signature found - try sha1
-                signatures = sc.GetSignature("", hash.sha1hash);
-            }
-
-            Models.Signatures_Games discoveredSignature = new Models.Signatures_Games();
-            if (signatures.Count == 1)
-            {
-                // only 1 signature found!
-                discoveredSignature = signatures.ElementAt(0);
-                gaseous_server.Models.PlatformMapping.GetIGDBPlatformMapping(ref discoveredSignature, fi, false);
-            }
-            else if (signatures.Count > 1)
-            {
-                // more than one signature found - find one with highest score
-                foreach (Models.Signatures_Games Sig in signatures)
-                {
-                    if (Sig.Score > discoveredSignature.Score)
-                    {
-                        discoveredSignature = Sig;
-                        gaseous_server.Models.PlatformMapping.GetIGDBPlatformMapping(ref discoveredSignature, fi, false);
-                    }
-                }
-            }
-            else
-            {
-                // no signature match found - try name search
-                signatures = sc.GetByTosecName(fi.Name);
-
-                if (signatures.Count == 1)
-                {
-                    // only 1 signature found!
-                    discoveredSignature = signatures.ElementAt(0);
-                    gaseous_server.Models.PlatformMapping.GetIGDBPlatformMapping(ref discoveredSignature, fi, false);
-                }
-                else if (signatures.Count > 1)
-                {
-                    // more than one signature found - find one with highest score
-                    foreach (Models.Signatures_Games Sig in signatures)
-                    {
-                        if (Sig.Score > discoveredSignature.Score)
-                        {
-                            discoveredSignature = Sig;
-                            gaseous_server.Models.PlatformMapping.GetIGDBPlatformMapping(ref discoveredSignature, fi, false);
-                        }
-                    }
-                }
-                else
-                {
-                    // still no search - try alternate method
-                    Models.Signatures_Games.GameItem gi = new Models.Signatures_Games.GameItem();
-                    Models.Signatures_Games.RomItem ri = new Models.Signatures_Games.RomItem();
-
-                    discoveredSignature.Game = gi;
-                    discoveredSignature.Rom = ri;
-
-                    // game title is the file name without the extension or path
-                    gi.Name = Path.GetFileNameWithoutExtension(GameFileImportPath);
-
-                    // remove everything after brackets - leaving (hopefully) only the name
-                    if (gi.Name.Contains("("))
-                    {
-                        gi.Name = gi.Name.Substring(0, gi.Name.IndexOf("("));
-                    }
-
-                    // remove special characters like dashes
-                    gi.Name = gi.Name.Replace("-", "");
-
-                    // guess platform
-                    gaseous_server.Models.PlatformMapping.GetIGDBPlatformMapping(ref discoveredSignature, fi, true);
-
-                    // get rom data
-                    ri.Name = Path.GetFileName(GameFileImportPath);
-                    ri.Md5 = hash.md5hash;
-                    ri.Sha1 = hash.sha1hash;
-                    ri.Size = fi.Length;
-                    ri.SignatureSource = gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType.None;
                 }
             }
 
-            Logging.Log(Logging.LogType.Information, "Import Game", "  Determined import file as: " + discoveredSignature.Game.Name + " (" + discoveredSignature.Game.Year + ") " + discoveredSignature.Game.System);
-
-            return discoveredSignature;
-        }
-
-        public static IGDB.Models.Game SearchForGame(string GameName, long PlatformId)
-        {
             // search discovered game - case insensitive exact match first
             IGDB.Models.Game determinedGame = new IGDB.Models.Game();
 
+            string GameName = Signature.Game.Name;
+
             List<string> SearchCandidates = GetSearchCandidates(GameName);
 
             foreach (string SearchCandidate in SearchCandidates)
@@ -318,8 +229,10 @@ 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) {
+                        foreach (Game game in games)
-                            if (game.Name == SearchCandidate) {
+                        {
+                            if (game.Name == SearchCandidate)
+                            {
                                 // found game title matches the search candidate
                                 determinedGame = Metadata.Games.GetGame((long)games[0].Id, false, false, false);
                                 Logging.Log(Logging.LogType.Information, "Import Game", "Found exact match!");
@@ -394,7 +307,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);
             }
 
@@ -415,7 +329,7 @@ namespace gaseous_server.Classes
             return SearchCandidates;
         }
 
-        public static long StoreROM(GameLibrary.LibraryItem library, Common.hashObject hash, IGDB.Models.Game determinedGame, IGDB.Models.Platform determinedPlatform, Models.Signatures_Games discoveredSignature, string GameFileImportPath, long UpdateId = 0)
+        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);
 
@@ -425,10 +339,11 @@ namespace gaseous_server.Classes
 
             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);";
+                sql = "INSERT INTO Games_Roms (PlatformId, GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, Path, MetadataSource, MetadataGameName, MetadataVersion, LibraryId, RomDataVersion) VALUES (@platformid, @gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @Attributes, @romtype, @romtypemedia, @medialabel, @path, @metadatasource, @metadatagamename, @metadataversion, @libraryid, @romdataversion); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-            } else
+            }
+            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;";
+                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 WHERE Id=@id;";
                 dbDict.Add("id", UpdateId);
             }
             dbDict.Add("platformid", Common.ReturnValueIfNull(determinedPlatform.Id, 0));
@@ -443,6 +358,7 @@ namespace gaseous_server.Classes
             dbDict.Add("metadatagamename", discoveredSignature.Game.Name);
             dbDict.Add("metadataversion", 2);
             dbDict.Add("libraryid", library.Id);
+            dbDict.Add("romdataversion", 2);
 
             if (discoveredSignature.Rom.Attributes != null)
             {
@@ -469,7 +385,8 @@ namespace gaseous_server.Classes
             if (UpdateId == 0)
             {
                 romId = (long)romInsert.Rows[0][0];
-            } else
+            }
+            else
             {
                 romId = UpdateId;
             }
@@ -558,7 +475,7 @@ namespace gaseous_server.Classes
             }
         }
 
-		public static void OrganiseLibrary()
+        public void OrganiseLibrary()
         {
             Logging.Log(Logging.LogType.Information, "Organise Library", "Starting default library organisation");
 
@@ -573,13 +490,15 @@ namespace gaseous_server.Classes
 
             if (romDT.Rows.Count > 0)
             {
-				foreach (DataRow dr in romDT.Rows)
+                for (int i = 0; i < romDT.Rows.Count; i++)
                 {
-					Logging.Log(Logging.LogType.Information, "Organise Library", "Processing ROM " + dr["name"]);
+                    SetStatus(i, romDT.Rows.Count, "Processing file " + romDT.Rows[i]["name"]);
-                    long RomId = (long)dr["id"];
+                    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);
                 }
             }
+            ClearStatus();
 
             // clean up empty directories
             DeleteOrphanedDirectories(GameLibrary.GetDefaultLibrary.Path);
@@ -592,19 +511,125 @@ namespace gaseous_server.Classes
             foreach (var directory in Directory.GetDirectories(startLocation))
             {
                 DeleteOrphanedDirectories(directory);
-                if (Directory.GetFiles(directory).Length == 0 &&
+
-                    Directory.GetDirectories(directory).Length == 0)
+                string[] files = Directory.GetFiles(directory);
+                string[] directories = Directory.GetDirectories(directory);
+
+                if (files.Length == 0 &&
+                    directories.Length == 0)
                 {
                     Directory.Delete(directory, false);
                 }
             }
         }
 
-        public static void LibraryScan()
+        public static List<GameLibrary.LibraryItem> LibrariesToScan = new List<GameLibrary.LibraryItem>();
+        public void LibraryScan()
         {
-            foreach (GameLibrary.LibraryItem library in GameLibrary.GetLibraries)
+            int maxWorkers = Config.MetadataConfiguration.MaxLibraryScanWorkers;
+
+            if (LibrariesToScan.Count == 0)
             {
-                Logging.Log(Logging.LogType.Information, "Library Scan", "Starting library scan. Library " + library.Name);
+                LibrariesToScan.AddRange(GameLibrary.GetLibraries);
+            }
+
+            // setup background tasks for each library
+            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(
+                        ProcessQueue.QueueItemType.LibraryScanWorker,
+                        1,
+                        new List<ProcessQueue.QueueItemType>
+                        {
+                        ProcessQueue.QueueItemType.OrganiseLibrary,
+                        ProcessQueue.QueueItemType.Rematcher
+                        },
+                        false,
+                        true)
+                    {
+                        Options = library
+                    };
+                    queue.ForceExecute();
+
+                    ProcessQueue.QueueItems.Add(queue);
+
+                    // check number of running tasks is less than maxWorkers
+                    bool allowContinue;
+                    do
+                    {
+                        allowContinue = true;
+                        int currentWorkerCount = 0;
+                        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)
+                            {
+                                currentWorkerCount += 1;
+                            }
+                        }
+                        if (currentWorkerCount >= maxWorkers)
+                        {
+                            allowContinue = false;
+                            Thread.Sleep(60000);
+                        }
+                    } while (allowContinue == false);
+                }
+            } while (LibrariesToScan.Count > 0);
+
+            bool WorkersStillWorking;
+            do
+            {
+                WorkersStillWorking = false;
+                List<ProcessQueue.QueueItem> queueItems = new List<ProcessQueue.QueueItem>();
+                queueItems.AddRange(ProcessQueue.QueueItems);
+                foreach (ProcessQueue.QueueItem item in queueItems)
+                {
+                    if (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker)
+                    {
+                        // workers are still running - sleep and keep looping
+                        WorkersStillWorking = true;
+                        Thread.Sleep(30000);
+                    }
+                }
+            } 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)
+        {
+
+            Logging.Log(Logging.LogType.Information, "Library Scan", "Starting scan of library: " + library.Name);
 
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
@@ -639,14 +664,16 @@ namespace gaseous_server.Classes
                 }
             }
 
-                sql = "SELECT * FROM Games_Roms ORDER BY `name`";
+            sql = "SELECT * FROM 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
             Logging.Log(Logging.LogType.Information, "Library Scan", "Looking for orphaned library files to add");
             string[] LibraryFiles = Directory.GetFiles(library.Path, "*.*", SearchOption.AllDirectories);
+            int StatusCount = 0;
             foreach (string LibraryFile in LibraryFiles)
             {
+                SetStatus(StatusCount, LibraryFiles.Length, "Processing file " + LibraryFile);
                 if (!Common.SkippableFiles.Contains<string>(Path.GetFileName(LibraryFile), StringComparer.OrdinalIgnoreCase))
                 {
                     Common.hashObject LibraryFileHash = new Common.hashObject(LibraryFile);
@@ -669,53 +696,61 @@ namespace gaseous_server.Classes
                     if (romFound == false)
                     {
                         // file is not in database - process it
+                        Logging.Log(Logging.LogType.Information, "Library Scan", "Orphaned file found in library: " + LibraryFile);
+
                         Common.hashObject hash = new Common.hashObject(LibraryFile);
                         FileInfo fi = new FileInfo(LibraryFile);
 
-                            Models.Signatures_Games sig = GetFileSignature(hash, fi, LibraryFile);
+                        FileSignature fileSignature = new FileSignature();
-
+                        gaseous_server.Models.Signatures_Games sig = fileSignature.GetFileSignature(library, hash, fi, LibraryFile);
-                            Logging.Log(Logging.LogType.Information, "Library Scan", " Orphaned file found in library: " + LibraryFile);
 
+                        try
+                        {
                             // get discovered platform
-                            IGDB.Models.Platform determinedPlatform = Metadata.Platforms.GetPlatform(sig.Flags.IGDBPlatformId);
+                            long PlatformId;
+                            IGDB.Models.Platform determinedPlatform;
 
-                            IGDB.Models.Game determinedGame = new Game();
+                            if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0)
-                            if (determinedPlatform == null)
                             {
-                                if (library.DefaultPlatformId == 0)
+                                // no platform discovered in the signature
-                                {
+                                PlatformId = library.DefaultPlatformId;
-                                    determinedPlatform = new IGDB.Models.Platform();
-                                    determinedGame = SearchForGame(sig.Game.Name, sig.Flags.IGDBPlatformId);
                             }
                             else
                             {
-                                    determinedPlatform = Platforms.GetPlatform(library.DefaultPlatformId);
+                                // use the platform discovered in the signature
-                                    determinedGame = SearchForGame(sig.Game.Name, library.DefaultPlatformId);
+                                PlatformId = sig.Flags.IGDBPlatformId;
-                                }
-                            }
-                            else
-                            {
-                                determinedGame = SearchForGame(sig.Game.Name, (long)determinedPlatform.Id);
                             }
+                            determinedPlatform = Platforms.GetPlatform(PlatformId);
+
+                            IGDB.Models.Game determinedGame = SearchForGame(sig, PlatformId, true);
 
                             StoreROM(library, hash, determinedGame, determinedPlatform, sig, LibraryFile);
                         }
+                        catch (Exception ex)
+                        {
+                            Logging.Log(Logging.LogType.Warning, "Library Scan", "An error occurred while matching orphaned file: " + LibraryFile + ". Skipping.", ex);
                         }
                     }
+                }
+                StatusCount += 1;
+            }
+            ClearStatus();
 
             sql = "SELECT * FROM Games_Roms WHERE LibraryId=@libraryid ORDER BY `name`";
             dtRoms = db.ExecuteCMD(sql, dbDict);
 
             // check all roms to see if their local file still exists
             Logging.Log(Logging.LogType.Information, "Library Scan", "Checking library files exist on disk");
+            StatusCount = 0;
             if (dtRoms.Rows.Count > 0)
             {
                 for (var i = 0; i < dtRoms.Rows.Count; i++)
                 {
                     long romId = (long)dtRoms.Rows[i]["Id"];
                     string romPath = (string)dtRoms.Rows[i]["Path"];
-                        gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType romMetadataSource = (gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType)(int)dtRoms.Rows[i]["MetadataSource"];
+                    gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType romMetadataSource = (gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType)(int)dtRoms.Rows[i]["MetadataSource"];
 
+                    SetStatus(StatusCount, dtRoms.Rows.Count, "Processing file " + romPath);
                     Logging.Log(Logging.LogType.Information, "Library Scan", "Processing ROM at path " + romPath);
 
                     if (File.Exists(romPath))
@@ -724,8 +759,13 @@ 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);
                             }
+                            else
+                            {
+                                Logging.Log(Logging.LogType.Information, "Library Scan", "ROM at path " + romPath + " found");
+                            }
                         }
                     }
                     else
@@ -739,35 +779,42 @@ namespace gaseous_server.Classes
                         deleteDict.Add("libraryid", library.Id);
                         db.ExecuteCMD(deleteSql, deleteDict);
                     }
+
+                    StatusCount += 1;
                 }
             }
 
             Logging.Log(Logging.LogType.Information, "Library Scan", "Library scan completed");
         }
-        }
 
-        public static void Rematcher(bool ForceExecute = false)
+        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 OR GameId = 0 OR MetadataSource = 0) AND (LastMatchAttemptDate IS NULL OR LastMatchAttemptDate < @lastmatchattemptdate) LIMIT 100;";
+                    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 OR GameId = 0 OR MetadataSource = 0);";
+                    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)
                 {
-                // get library
+                    SetStatus(StatusCount, data.Rows.Count, "Running rematcher");
-                GameLibrary.LibraryItem library = GameLibrary.GetLibrary((int)row["LibraryId"]);
 
                     // get rom info
                     long romId = (long)row["Id"];
@@ -782,16 +829,26 @@ namespace gaseous_server.Classes
                     Logging.Log(Logging.LogType.Information, "Rematch Scan", "Running rematch against " + romPath);
 
                     // determine rom signature
-                Models.Signatures_Games sig = GetFileSignature(hash, fi, romPath);
+                    FileSignature fileSignature = new FileSignature();
+                    gaseous_server.Models.Signatures_Games sig = fileSignature.GetFileSignature(library, hash, fi, romPath);
 
-                // determine rom platform
+                    // get discovered platform
-                IGDB.Models.Platform determinedPlatform = Metadata.Platforms.GetPlatform(sig.Flags.IGDBPlatformId);
+                    long PlatformId;
-                if (determinedPlatform == null)
+                    IGDB.Models.Platform determinedPlatform;
+
+                    if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0)
                     {
-                    determinedPlatform = new IGDB.Models.Platform();
+                        // 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.Game.Name, sig.Flags.IGDBPlatformId);
+                    IGDB.Models.Game determinedGame = SearchForGame(sig, PlatformId, true);
 
                     StoreROM(library, hash, determinedGame, determinedPlatform, sig, romPath, romId);
 
@@ -800,9 +857,14 @@ namespace gaseous_server.Classes
                     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,10 +3,12 @@ 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
     {
+        private static DateTime lastDiskRetentionSweep = DateTime.UtcNow;
         public static bool WriteToDiskOnly { get; set; } = false;
 
         static public void Log(LogType EventType, string ServerProcess, string Message, Exception? ExceptionValue = null, bool LogToDiskOnly = false)
@@ -20,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)
                 {
@@ -41,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.WriteLine(consoleColour + TraceOutput);
-                Console.ResetColor();
+                // Console.ResetColor();
 
                 if (WriteToDiskOnly == true)
                 {
@@ -69,15 +82,73 @@ namespace gaseous_server.Classes
 
                 if (LogToDiskOnly == false)
                 {
+                    if (Config.LoggingConfiguration.AlwaysLogToDisk == true)
+                    {
+                        LogToDisk(logItem, TraceOutput, null);
+                    }
+
+                    string correlationId;
+                    try
+                    {
+                        if (CallContext.GetData("CorrelationId").ToString() == null)
+                        {
+                            correlationId = "";
+                        }
+                        else
+                        {
+                            correlationId = CallContext.GetData("CorrelationId").ToString();
+                        }
+                    }
+                    catch
+                    {
+                        correlationId = "";
+                    }
+
+                    string callingProcess;
+                    try
+                    {
+                        if (CallContext.GetData("CallingProcess").ToString() == null)
+                        {
+                            callingProcess = "";
+                        }
+                        else
+                        {
+                            callingProcess = CallContext.GetData("CallingProcess").ToString();
+                        }
+                    }
+                    catch
+                    {
+                        callingProcess = "";
+                    }
+
+                    string callingUser;
+                    try
+                    {
+                        if (CallContext.GetData("CallingUser").ToString() == null)
+                        {
+                            callingUser = "";
+                        }
+                        else
+                        {
+                            callingUser = CallContext.GetData("CallingUser").ToString();
+                        }
+                    }
+                    catch
+                    {
+                        callingUser = "";
+                    }
+
                     Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-                    string sql = "DELETE FROM ServerLogs WHERE EventTime < @EventRententionDate; INSERT INTO ServerLogs (EventTime, EventType, Process, Message, Exception) VALUES (@EventTime, @EventType, @Process, @Message, @Exception);";
+                    string sql = "INSERT INTO ServerLogs (EventTime, EventType, Process, Message, Exception, CorrelationId, CallingProcess, CallingUser) VALUES (@EventTime, @EventType, @Process, @Message, @Exception, @correlationid, @callingprocess, @callinguser);";
                     Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                    dbDict.Add("EventRententionDate", DateTime.UtcNow.AddDays(Config.LoggingConfiguration.LogRetention * -1));
                     dbDict.Add("EventTime", logItem.EventTime);
                     dbDict.Add("EventType", logItem.EventType);
                     dbDict.Add("Process", logItem.Process);
                     dbDict.Add("Message", logItem.Message);
                     dbDict.Add("Exception", Common.ReturnValueIfNull(logItem.ExceptionValue, "").ToString());
+                    dbDict.Add("correlationid", correlationId);
+                    dbDict.Add("callingprocess", callingProcess);
+                    dbDict.Add("callinguser", callingUser);
 
                     try
                     {
@@ -93,6 +164,22 @@ namespace gaseous_server.Classes
                     LogToDisk(logItem, TraceOutput, null);
                 }
             }
+
+            if (lastDiskRetentionSweep.AddMinutes(60) < DateTime.UtcNow)
+            {
+                // time to delete any old logs
+                lastDiskRetentionSweep = DateTime.UtcNow;
+                string[] files = Directory.GetFiles(Config.LogPath);
+
+                foreach (string file in files)
+                {
+                    FileInfo fi = new FileInfo(file);
+                    if (fi.LastAccessTime < DateTime.Now.AddDays(Config.LoggingConfiguration.LogRetention * -1))
+                    {
+                        fi.Delete();
+                    }
+                }
+            }
         }
 
         static void LogToDisk(LogItem logItem, string TraceOutput, Exception? exception)
@@ -110,22 +197,111 @@ namespace gaseous_server.Classes
             File.AppendAllText(Config.LogFilePath, TraceOutput);
         }
 
-        static public List<LogItem> GetLogs(long? StartIndex, int PageNumber = 1, int PageSize = 100) 
+        static public List<LogItem> GetLogs(LogsViewModel model)
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("StartIndex", model.StartIndex);
+            dbDict.Add("PageNumber", (model.PageNumber - 1) * model.PageSize);
+            dbDict.Add("PageSize", model.PageSize);
             string sql = "";
-            if (StartIndex == null)
+
+            List<string> whereClauses = new List<string>();
+
+            // handle status criteria
+            if (model.Status != null)
             {
-                sql = "SELECT * FROM ServerLogs ORDER BY Id DESC LIMIT @PageSize OFFSET @PageNumber;";
+                if (model.Status.Count > 0)
+                {
+                    List<string> statusWhere = new List<string>();
+                    for (int i = 0; i < model.Status.Count; i++)
+                    {
+                        string valueName = "@eventtype" + i;
+                        statusWhere.Add(valueName);
+                        dbDict.Add(valueName, (int)model.Status[i]);
+                    }
+
+                    whereClauses.Add("EventType IN (" + string.Join(",", statusWhere) + ")");
+                }
+            }
+
+            // handle start date criteria
+            if (model.StartDateTime != null)
+            {
+                dbDict.Add("startdate", model.StartDateTime);
+                whereClauses.Add("EventTime >= @startdate");
+            }
+
+            // handle end date criteria
+            if (model.EndDateTime != null)
+            {
+                dbDict.Add("enddate", model.EndDateTime);
+                whereClauses.Add("EventTime <= @enddate");
+            }
+
+            // handle search text criteria
+            if (model.SearchText != null)
+            {
+                if (model.SearchText.Length > 0)
+                {
+                    dbDict.Add("messageSearch", model.SearchText);
+                    whereClauses.Add("MATCH(Message) AGAINST (@messageSearch)");
+                }
+            }
+
+            if (model.CorrelationId != null)
+            {
+                if (model.CorrelationId.Length > 0)
+                {
+                    dbDict.Add("correlationId", model.CorrelationId);
+                    whereClauses.Add("CorrelationId = @correlationId");
+                }
+            }
+
+            if (model.CallingProcess != null)
+            {
+                if (model.CallingProcess.Length > 0)
+                {
+                    dbDict.Add("callingProcess", model.CallingProcess);
+                    whereClauses.Add("CallingProcess = @callingProcess");
+                }
+            }
+
+            if (model.CallingUser != null)
+            {
+                if (model.CallingUser.Length > 0)
+                {
+                    dbDict.Add("callingUser", model.CallingUser);
+                    whereClauses.Add("CallingUser = @callingUser");
+                }
+            }
+
+            // compile WHERE clause
+            string whereClause = "";
+            if (whereClauses.Count > 0)
+            {
+                whereClause = "(" + String.Join(" AND ", whereClauses) + ")";
+            }
+
+            // execute query
+            if (model.StartIndex == null)
+            {
+                if (whereClause.Length > 0)
+                {
+                    whereClause = "WHERE " + whereClause;
+                }
+
+                sql = "SELECT ServerLogs.Id, ServerLogs.EventTime, ServerLogs.EventType, ServerLogs.`Process`, ServerLogs.Message, ServerLogs.Exception, ServerLogs.CorrelationId, ServerLogs.CallingProcess, Users.Email FROM ServerLogs LEFT JOIN Users ON ServerLogs.CallingUser = Users.Id " + whereClause + " ORDER BY ServerLogs.Id DESC LIMIT @PageSize OFFSET @PageNumber;";
             }
             else
             {
-                sql = "SELECT * FROM ServerLogs WHERE Id < @StartIndex ORDER BY Id DESC LIMIT @PageSize OFFSET @PageNumber;";
+                if (whereClause.Length > 0)
+                {
+                    whereClause = "AND " + whereClause;
+                }
+
+                sql = "SELECT ServerLogs.Id, ServerLogs.EventTime, ServerLogs.EventType, ServerLogs.`Process`, ServerLogs.Message, ServerLogs.Exception, ServerLogs.CorrelationId, ServerLogs.CallingProcess, Users.Email FROM ServerLogs LEFT JOIN Users ON ServerLogs.CallingUser = Users.Id  WHERE ServerLogs.Id < @StartIndex " + whereClause + " ORDER BY ServerLogs.Id DESC LIMIT @PageSize OFFSET @PageNumber;";
             }
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("StartIndex", StartIndex);
-            dbDict.Add("PageNumber", (PageNumber - 1) * PageSize);
-            dbDict.Add("PageSize", PageSize);
             DataTable dataTable = db.ExecuteCMD(sql, dbDict);
 
             List<LogItem> logs = new List<LogItem>();
@@ -138,7 +314,10 @@ namespace gaseous_server.Classes
                     EventType = (LogType)row["EventType"],
                     Process = (string)row["Process"],
                     Message = (string)row["Message"],
-                    ExceptionValue = (string)row["Exception"]
+                    ExceptionValue = (string)row["Exception"],
+                    CorrelationId = (string)Common.ReturnValueIfNull(row["CorrelationId"], ""),
+                    CallingProcess = (string)Common.ReturnValueIfNull(row["CallingProcess"], ""),
+                    CallingUser = (string)Common.ReturnValueIfNull(row["Email"], "")
                 };
 
                 logs.Add(log);
@@ -161,6 +340,9 @@ namespace gaseous_server.Classes
             public DateTime EventTime { get; set; }
             public LogType? EventType { get; set; }
             public string Process { get; set; } = "";
+            public string CorrelationId { get; set; } = "";
+            public string? CallingProcess { get; set; } = "";
+            public string? CallingUser { get; set; } = "";
             private string _Message = "";
             public string Message
             {
@@ -175,6 +357,20 @@ namespace gaseous_server.Classes
             }
             public string? ExceptionValue { get; set; }
         }
+
+        public class LogsViewModel
+        {
+            public long? StartIndex { get; set; }
+            public int PageNumber { get; set; } = 1;
+            public int PageSize { get; set; } = 100;
+            public List<LogType> Status { get; set; } = new List<LogType>();
+            public DateTime? StartDateTime { get; set; }
+            public DateTime? EndDateTime { get; set; }
+            public string? SearchText { get; set; }
+            public string? CorrelationId { get; set; }
+            public string? CallingProcess { get; set; }
+            public string? CallingUser { get; set; }
+        }
     }
 }
 

gaseous-server/Classes/Maintenance.cs

@@ -5,12 +5,59 @@ using Microsoft.VisualStudio.Web.CodeGeneration;
 
 namespace gaseous_server.Classes
 {
-	public class Maintenance
+    public class Maintenance : QueueItemStatus
     {
         const int MaxFileAge = 30;
 
-        public static void RunMaintenance()
+        public void RunDailyMaintenance()
         {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "";
+            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)
+            {
+                if (LibraryWhereClause.Length > 0)
+                {
+                    LibraryWhereClause += ", ";
+                }
+                LibraryWhereClause += library.Id;
+            }
+            string sqlLibraryWhereClause = "";
+            if (LibraryWhereClause.Length > 0)
+            {
+                sqlLibraryWhereClause = "DELETE FROM Games_Roms WHERE LibraryId NOT IN ( " + LibraryWhereClause + " );";
+                db.ExecuteCMD(sqlLibraryWhereClause);
+            }
+
+            // delete old logs
+            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));
+            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>();
             PathsToClean.Add(Config.LibraryConfiguration.LibraryUploadDirectory);
@@ -43,16 +90,25 @@ namespace gaseous_server.Classes
                     }
                 }
             }
+        }
+
+        public void RunWeeklyMaintenance()
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
 
             Logging.Log(Logging.LogType.Information, "Maintenance", "Optimising database tables");
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            sql = "SHOW FULL TABLES WHERE Table_Type = 'BASE TABLE';";
-            string sql = "SHOW TABLES;";
             DataTable tables = db.ExecuteCMD(sql);
 
+            int StatusCounter = 1;
             foreach (DataRow row in tables.Rows)
             {
+                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 = "";
@@ -60,9 +116,12 @@ namespace gaseous_server.Classes
                     {
                         retVal += responseRow.ItemArray[i] + "; ";
                     }
-                    Logging.Log(Logging.LogType.Information, "Maintenance", "Optimizse table " + row[0].ToString() + ": " + retVal);
+                    Logging.Log(Logging.LogType.Information, "Maintenance", "(" + StatusCounter + "/" + tables.Rows.Count + "): Optimise table " + row[0].ToString() + ": " + retVal);
-                }
+                }
-            }
+
+                StatusCounter += 1;
+            }
+            ClearStatus();
         }
     }
 }

gaseous-server/Classes/Metadata/AgeGroups.cs

@@ -0,0 +1,316 @@
+using System;
+using System.Reflection;
+using System.Text.Json.Serialization;
+using IGDB;
+using IGDB.Models;
+using Microsoft.CodeAnalysis.Classification;
+
+namespace gaseous_server.Classes.Metadata
+{
+    public class AgeGroups
+    {
+        public AgeGroups()
+        {
+
+        }
+
+        public static AgeGroup? GetAgeGroup(Game? game)
+        {
+            if (game == null)
+            {
+                return null;
+            }
+            else
+            {
+                Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
+                cacheStatus = Storage.GetCacheStatus("AgeGroup", (long)game.Id);
+
+                AgeGroup? RetVal = new AgeGroup();
+
+                switch (cacheStatus)
+                {
+                    case Storage.CacheStatus.NotPresent:
+                        RetVal = _GetAgeGroup(game);
+                        Storage.NewCacheValue(RetVal, false);
+                        break;
+
+                    case Storage.CacheStatus.Expired:
+                        RetVal = _GetAgeGroup(game);
+                        Storage.NewCacheValue(RetVal, true);
+                        break;
+
+                    case Storage.CacheStatus.Current:
+                        RetVal = Storage.GetCacheValue<AgeGroup>(RetVal, "Id", game.Id);
+                        break;
+
+                    default:
+                        throw new Exception("How did you get here?");
+                }
+
+                return RetVal;
+            }
+        }
+
+        public static AgeGroup? _GetAgeGroup(Game game)
+        {
+            // compile the maximum age group for the given game
+            if (game != null)
+            {
+                if (game.AgeRatings != null)
+                {
+                    if (game.AgeRatings.Ids != null)
+                    {
+                        // collect ratings values from metadata
+                        List<AgeRating> ageRatings = new List<AgeRating>();
+                        foreach (long ratingId in game.AgeRatings.Ids)
+                        {
+                            AgeRating? rating = AgeRatings.GetAgeRatings(ratingId);
+                            if (rating != null)
+                            {
+                                ageRatings.Add(rating);
+                            }
+                        }
+
+                        // compile the ratings values into the ratings groups
+                        AgeRestrictionGroupings highestAgeGroup = GetAgeGroupFromAgeRatings(ageRatings);
+
+                        // return the compiled ratings group
+                        AgeGroup ageGroup = new AgeGroup();
+                        ageGroup.Id = game.Id;
+                        ageGroup.GameId = game.Id;
+                        if (highestAgeGroup == 0)
+                        {
+                            ageGroup.AgeGroupId = null;
+                        }
+                        else
+                        {
+                            ageGroup.AgeGroupId = highestAgeGroup;
+                        }
+
+                        return ageGroup;
+                    }
+                    else
+                    {
+                        AgeGroup ageGroup = new AgeGroup();
+                        ageGroup.Id = game.Id;
+                        ageGroup.GameId = game.Id;
+                        ageGroup.AgeGroupId = null;
+
+                        return ageGroup;
+                    }
+                }
+                else
+                {
+                    AgeGroup ageGroup = new AgeGroup();
+                    ageGroup.Id = game.Id;
+                    ageGroup.GameId = game.Id;
+                    ageGroup.AgeGroupId = null;
+
+                    return ageGroup;
+                }
+            }
+
+            return null;
+        }
+
+        public static AgeRestrictionGroupings GetAgeGroupFromAgeRatings(List<AgeRating> ageRatings)
+        {
+            // compile the ratings values into the ratings groups
+            AgeRestrictionGroupings highestAgeGroup = AgeRestrictionGroupings.Unclassified;
+            foreach (AgeRating ageRating in ageRatings)
+            {
+                foreach (KeyValuePair<AgeRestrictionGroupings, AgeGroupItem> ageGroupItem in AgeGroupingsFlat)
+                {
+
+                    PropertyInfo[] groupProps = typeof(AgeGroupItem).GetProperties();
+                    foreach (PropertyInfo property in groupProps)
+                    {
+                        if (RatingsBoards.Contains(property.Name))
+                        {
+                            List<AgeRatingTitle> ratingBoard = (List<AgeRatingTitle>)property.GetValue(ageGroupItem.Value);
+                            foreach (AgeRatingTitle ratingTitle in ratingBoard)
+                            {
+                                if (ageRating.Rating == ratingTitle)
+                                {
+                                    if (highestAgeGroup < ageGroupItem.Key)
+                                    {
+                                        highestAgeGroup = ageGroupItem.Key;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return highestAgeGroup;
+        }
+
+        public class AgeGroup
+        {
+            public long? Id { get; set; }
+            public long? GameId { get; set; }
+            public AgeRestrictionGroupings? AgeGroupId { get; set; }
+        }
+
+        public static Dictionary<AgeRestrictionGroupings, List<AgeGroupItem>> AgeGroupings
+        {
+            get
+            {
+                return new Dictionary<AgeRestrictionGroupings, List<AgeGroupItem>>{
+                    {
+                        AgeRestrictionGroupings.Adult, new List<AgeGroupItem>{ Adult_Item, Mature_Item, Teen_Item, Child_Item }
+                    },
+                    {
+                        AgeRestrictionGroupings.Mature, new List<AgeGroupItem>{ Mature_Item, Teen_Item, Child_Item }
+                    },
+                    {
+                        AgeRestrictionGroupings.Teen, new List<AgeGroupItem>{ Teen_Item, Child_Item }
+                    },
+                    {
+                        AgeRestrictionGroupings.Child, new List<AgeGroupItem>{ Child_Item }
+                    }
+                };
+            }
+        }
+
+        public static Dictionary<AgeRestrictionGroupings, AgeGroupItem> AgeGroupingsFlat
+        {
+            get
+            {
+                return new Dictionary<AgeRestrictionGroupings, AgeGroupItem>{
+                    {
+                        AgeRestrictionGroupings.Adult, Adult_Item
+                    },
+                    {
+                        AgeRestrictionGroupings.Mature, Mature_Item
+                    },
+                    {
+                        AgeRestrictionGroupings.Teen, Teen_Item
+                    },
+                    {
+                        AgeRestrictionGroupings.Child, Child_Item
+                    }
+                };
+            }
+        }
+
+        public enum AgeRestrictionGroupings
+        {
+            Adult = 4,
+            Mature = 3,
+            Teen = 2,
+            Child = 1,
+            Unclassified = 0
+        }
+
+        public static List<string> RatingsBoards
+        {
+            get
+            {
+                List<string> boards = new List<string>{
+                    "ACB", "CERO", "CLASS_IND", "ESRB", "GRAC", "PEGI", "USK"
+                };
+
+                return boards;
+            }
+        }
+
+        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 },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.RP, AgeRatingTitle.AO },
+            GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_Eighteen },
+            PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Eighteen },
+            USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_18 }
+        };
+
+        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 },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.M },
+            GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_Fifteen },
+            PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Sixteen },
+            USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_16 }
+        };
+
+        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 },
+            ESRB = new List<AgeRatingTitle> { AgeRatingTitle.T },
+            GRAC = new List<AgeRatingTitle> { AgeRatingTitle.GRAC_Twelve },
+            PEGI = new List<AgeRatingTitle> { AgeRatingTitle.Twelve },
+            USK = new List<AgeRatingTitle> { AgeRatingTitle.USK_12 }
+        };
+
+        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.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 }
+        };
+
+        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; }
+
+            [JsonIgnore]
+            [Newtonsoft.Json.JsonIgnore]
+            public List<long> AgeGroupItemValues
+            {
+                get
+                {
+                    List<long> values = new List<long>();
+                    {
+                        foreach (AgeRatingTitle ageRatingTitle in ACB)
+                        {
+                            values.Add((long)ageRatingTitle);
+                        }
+                        foreach (AgeRatingTitle ageRatingTitle in CERO)
+                        {
+                            values.Add((long)ageRatingTitle);
+                        }
+                        foreach (AgeRatingTitle ageRatingTitle in CLASS_IND)
+                        {
+                            values.Add((long)ageRatingTitle);
+                        }
+                        foreach (AgeRatingTitle ageRatingTitle in ESRB)
+                        {
+                            values.Add((long)ageRatingTitle);
+                        }
+                        foreach (AgeRatingTitle ageRatingTitle in GRAC)
+                        {
+                            values.Add((long)ageRatingTitle);
+                        }
+                        foreach (AgeRatingTitle ageRatingTitle in PEGI)
+                        {
+                            values.Add((long)ageRatingTitle);
+                        }
+                        foreach (AgeRatingTitle ageRatingTitle in USK)
+                        {
+                            values.Add((long)ageRatingTitle);
+                        }
+                    }
+
+                    return values;
+                }
+            }
+        }
+    }
+}

gaseous-server/Classes/Metadata/AgeRating.cs

@@ -3,6 +3,7 @@ using System.Reflection;
 using System.Text.Json.Serialization;
 using IGDB;
 using IGDB.Models;
+using Microsoft.CodeAnalysis.Classification;
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -14,12 +15,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static AgeRating? GetAgeRatings(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -116,7 +111,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<AgeRating> GetObjectFromServer(string WhereClause)
         {
             // get AgeRatings metadata
-            var results = await igdb.QueryAsync<AgeRating>(IGDBClient.Endpoints.AgeRating, query: fieldList + " " + WhereClause + ";");
+            Communications comms = new Communications();
+            var results = await comms.APIComm<AgeRating>(IGDBClient.Endpoints.AgeRating, fieldList, WhereClause);
             var result = results.First();
 
             return result;
@@ -153,199 +149,41 @@ namespace gaseous_server.Classes.Metadata
             public string[] Descriptions { get; set; }
         }
 
-        public class AgeGroups
+        public static void PopulateAgeMap()
-        {
-            public AgeGroups()
         {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM ClassificationMap;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            db.ExecuteNonQuery(sql);
 
-            }
+            // loop all age groups
+            foreach(KeyValuePair<AgeGroups.AgeRestrictionGroupings, AgeGroups.AgeGroupItem> ageGrouping in AgeGroups.AgeGroupingsFlat)
+            {
+                AgeGroups.AgeGroupItem ageGroupItem = ageGrouping.Value;
+                var properties = ageGroupItem.GetType().GetProperties();
+                foreach (var prop in properties)
+                {
+                    if (prop.GetGetMethod() != null)
+                    {
+                        List<string> AgeRatingCategories = new List<string>(Enum.GetNames(typeof(AgeRatingCategory)));
+                        if (AgeRatingCategories.Contains(prop.Name))
+                        {
+                            AgeRatingCategory ageRatingCategory = (AgeRatingCategory)Enum.Parse(typeof(AgeRatingCategory), prop.Name);
+                            List<AgeRatingTitle> ageRatingTitles = (List<AgeRatingTitle>)prop.GetValue(ageGroupItem);
                             
-            public static Dictionary<string, List<AgeGroupItem>> AgeGroupings
+                            foreach (AgeRatingTitle ageRatingTitle in ageRatingTitles)
                             {
-                get
+                                dbDict.Clear();
-                {
+                                dbDict.Add("AgeGroupId", ageGrouping.Key);
-                    return new Dictionary<string, List<AgeGroupItem>>{
+                                dbDict.Add("ClassificationBoardId", ageRatingCategory);
-                        { 
+                                dbDict.Add("RatingId", ageRatingTitle);
-                            "Adult", new List<AgeGroupItem>{ Adult_Item, Mature_Item, Teen_Item, Child_Item } 
-                        },
-                        {
-                            "Mature", new List<AgeGroupItem>{ Mature_Item, Teen_Item, Child_Item }
-                        },
-                        {
-                            "Teen", new List<AgeGroupItem>{ Teen_Item, Child_Item }
-                        },
-                        { 
-                            "Child", new List<AgeGroupItem>{ Child_Item }
-                        }
-                    };
-                }
-            }
 
-            public static Dictionary<string, AgeGroupItem> AgeGroupingsFlat
+                                sql = "INSERT INTO ClassificationMap (AgeGroupId, ClassificationBoardId, RatingId) VALUES (@AgeGroupId, @ClassificationBoardId, @RatingId);";
-            {
+                                db.ExecuteCMD(sql, dbDict);
-                get
+                            }
-                {
-                    return new Dictionary<string, AgeGroupItem>{
-                        {
-                            "Adult", Adult_Item
-                        },
-                        {
-                            "Mature", Mature_Item
-                        },
-                        {
-                            "Teen", Teen_Item
-                        },
-                        {
-                            "Child", Child_Item
-                        }
-                    };
-                }
-            }
-
-            public static List<ClassificationBoardItem> ClassificationBoards
-            {
-                get
-                {
-                    ClassificationBoardItem boardItem = new ClassificationBoardItem{ 
-                        Board = AgeRatingCategory.ACB, 
-                        Classifications = new List<AgeRatingTitle>{
-                            AgeRatingTitle.ACB_G, AgeRatingTitle.ACB_M, AgeRatingTitle.ACB_MA15, AgeRatingTitle.ACB_R18, AgeRatingTitle.ACB_RC
-                        }
-                    };
-
-                    return new List<ClassificationBoardItem>{
-                        new ClassificationBoardItem{ 
-                            Board = AgeRatingCategory.ACB, 
-                            Classifications = new List<AgeRatingTitle>{
-                                AgeRatingTitle.ACB_G,
-                                AgeRatingTitle.ACB_M,
-                                AgeRatingTitle.ACB_MA15,
-                                AgeRatingTitle.ACB_R18,
-                                AgeRatingTitle.ACB_RC
-                            }
-                        },
-                        new ClassificationBoardItem{ 
-                            Board = AgeRatingCategory.CERO, 
-                            Classifications = new List<AgeRatingTitle>{
-                                AgeRatingTitle.CERO_A,
-                                AgeRatingTitle.CERO_B,
-                                AgeRatingTitle.CERO_C,
-                                AgeRatingTitle.CERO_D,
-                                AgeRatingTitle.CERO_Z
-                            }
-                        },
-                        new ClassificationBoardItem{ 
-                            Board = AgeRatingCategory.CLASS_IND, 
-                            Classifications = new List<AgeRatingTitle>{
-                                AgeRatingTitle.CLASS_IND_L,
-                                AgeRatingTitle.CLASS_IND_Ten,
-                                AgeRatingTitle.CLASS_IND_Twelve,
-                                AgeRatingTitle.CLASS_IND_Fourteen,
-                                AgeRatingTitle.CLASS_IND_Sixteen,
-                                AgeRatingTitle.CLASS_IND_Eighteen
-                            }
-                        }
-                    };
-                }
-            }
-
-            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 },
-                ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.RP, AgeRatingTitle.AO },
-                GRAC        = new List<AgeRatingTitle>{ AgeRatingTitle.GRAC_Eighteen },
-                PEGI        = new List<AgeRatingTitle>{ AgeRatingTitle.Eighteen},
-                USK         = new List<AgeRatingTitle>{ AgeRatingTitle.USK_18}
-            };
-
-            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 },
-                ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.M },
-                GRAC        = new List<AgeRatingTitle>{ AgeRatingTitle.GRAC_Fifteen },
-                PEGI        = new List<AgeRatingTitle>{ AgeRatingTitle.Sixteen},
-                USK         = new List<AgeRatingTitle>{ AgeRatingTitle.USK_16}
-            };
-
-            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 },
-                ESRB        = new List<AgeRatingTitle>{ AgeRatingTitle.T },
-                GRAC        = new List<AgeRatingTitle>{ AgeRatingTitle.GRAC_Twelve },
-                PEGI        = new List<AgeRatingTitle>{ AgeRatingTitle.Twelve},
-                USK         = new List<AgeRatingTitle>{ AgeRatingTitle.USK_12}
-            };
-
-            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 },
-                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}
-            };
-
-            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; }
-
-                [JsonIgnore]
-                [Newtonsoft.Json.JsonIgnore]
-                public List<long> AgeGroupItemValues
-                {
-                    get
-                    {
-                        List<long> values = new List<long>();
-                        {
-                            foreach (AgeRatingTitle ageRatingTitle in ACB)
-                            {
-                                values.Add((long)ageRatingTitle);
-                            }
-                            foreach (AgeRatingTitle ageRatingTitle in CERO)
-                            {
-                                values.Add((long)ageRatingTitle);
-                            }
-                            foreach (AgeRatingTitle ageRatingTitle in CLASS_IND)
-                            {
-                                values.Add((long)ageRatingTitle);
-                            }
-                            foreach (AgeRatingTitle ageRatingTitle in ESRB)
-                            {
-                                values.Add((long)ageRatingTitle);
-                            }
-                            foreach (AgeRatingTitle ageRatingTitle in GRAC)
-                            {
-                                values.Add((long)ageRatingTitle);
-                            }
-                            foreach (AgeRatingTitle ageRatingTitle in PEGI)
-                            {
-                                values.Add((long)ageRatingTitle);
-                            }
-                            foreach (AgeRatingTitle ageRatingTitle in USK)
-                            {
-                                values.Add((long)ageRatingTitle);
-                            }
-                        }
-
-                        return values;
                         }
                     }
                 }
-
-            public class ClassificationBoardItem
-            {
-                public IGDB.Models.AgeRatingCategory Board { get; set; }
-                public List<IGDB.Models.AgeRatingTitle> Classifications { get; set; }
             }
         }
 	}

gaseous-server/Classes/Metadata/AgeRatingContentDescriptions.cs

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static AgeRatingContentDescription? GetAgeRatingContentDescriptions(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<AgeRatingContentDescription> GetObjectFromServer(string WhereClause)
         {
             // get AgeRatingContentDescriptionContentDescriptions metadata
-            var results = await igdb.QueryAsync<AgeRatingContentDescription>(IGDBClient.Endpoints.AgeRatingContentDescriptions, query: fieldList + " " + WhereClause + ";");
+            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

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static AlternativeName? GetAlternativeNames(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<AlternativeName> GetObjectFromServer(string WhereClause)
         {
             // get AlternativeNames metadata
-            var results = await igdb.QueryAsync<AlternativeName>(IGDBClient.Endpoints.AlternativeNames, query: fieldList + " " + WhereClause + ";");
+            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

@@ -13,13 +13,7 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
+        public static Artwork? GetArtwork(long? Id, string ImagePath, bool GetImages)
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static Artwork? GetArtwork(long? Id, string LogoPath)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -27,18 +21,18 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Artwork> RetVal = _GetArtwork(SearchUsing.id, Id, LogoPath);
+                Task<Artwork> RetVal = _GetArtwork(SearchUsing.id, Id, ImagePath, GetImages);
                 return RetVal.Result;
             }
         }
 
-        public static Artwork GetArtwork(string Slug, string LogoPath)
+        public static Artwork GetArtwork(string Slug, string ImagePath, bool GetImages)
         {
-            Task<Artwork> RetVal = _GetArtwork(SearchUsing.slug, Slug, LogoPath);
+            Task<Artwork> RetVal = _GetArtwork(SearchUsing.slug, Slug, ImagePath, GetImages);
             return RetVal.Result;
         }
 
-        private static async Task<Artwork> _GetArtwork(SearchUsing searchUsing, object searchValue, string LogoPath)
+        private static async Task<Artwork> _GetArtwork(SearchUsing searchUsing, object searchValue, string ImagePath, bool GetImages = true)
         {
             // check database first
             Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -67,19 +61,26 @@ namespace gaseous_server.Classes.Metadata
 
             Artwork returnValue = new Artwork();
             bool forceImageDownload = false;
-            LogoPath = Path.Combine(LogoPath, "Artwork");
+            ImagePath = Path.Combine(ImagePath, "Artwork");
             switch (cacheStatus)
             {
                 case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                     Storage.NewCacheValue(returnValue);
                     forceImageDownload = true;
                     break;
                 case Storage.CacheStatus.Expired:
                     try
                     {
-                        returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                         Storage.NewCacheValue(returnValue, true);
+
+                        // check if old value is different from the new value - only download if it's different
+                        Artwork oldImage = Storage.GetCacheValue<Artwork>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
+                            forceImageDownload = true;
+                        }
                     }
                     catch (Exception ex)
                     {
@@ -94,11 +95,17 @@ namespace gaseous_server.Classes.Metadata
                     throw new Exception("How did you get here?");
             }
 
-            if ((!File.Exists(Path.Combine(LogoPath, returnValue.ImageId + ".jpg"))) || forceImageDownload == true)
+            // 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)
             {
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_thumb, returnValue.ImageId);
+                if ((!File.Exists(localFile)) || forceImageDownload == true)
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med, returnValue.ImageId);
+                {
-                GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_original, returnValue.ImageId);
+                    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;
@@ -110,64 +117,15 @@ namespace gaseous_server.Classes.Metadata
             slug
         }
 
-        private static async Task<Artwork> GetObjectFromServer(string WhereClause, string LogoPath)
+        private static async Task<Artwork> GetObjectFromServer(string WhereClause, string ImagePath)
         {
             // get Artwork metadata
-            var results = await igdb.QueryAsync<Artwork>(IGDBClient.Endpoints.Artworks, query: fieldList + " " + WhereClause + ";");
+            Communications comms = new Communications();
+            var results = await comms.APIComm<Artwork>(IGDBClient.Endpoints.Artworks, fieldList, WhereClause);
             var result = results.First();
 
-            //GetImageFromServer(result.Url, LogoPath, LogoSize.t_thumb, result.ImageId);
-            //GetImageFromServer(result.Url, LogoPath, LogoSize.t_logo_med, result.ImageId);
-            GetImageFromServer(result.Url, LogoPath, LogoSize.t_original, result.ImageId);
-
             return result;
         }
-
-        private static void GetImageFromServer(string Url, string LogoPath, LogoSize logoSize, string ImageId)
-        {
-            using (var client = new HttpClient())
-            {
-                string fileName = "Artwork.jpg";
-                string extension = "jpg";
-                switch (logoSize)
-                {
-                    case LogoSize.t_thumb:
-                        fileName = "_Thumb";
-                        extension = "jpg";
-                        break;
-                    case LogoSize.t_logo_med:
-                        fileName = "_Medium";
-                        extension = "png";
-                        break;
-                    case LogoSize.t_original:
-                        fileName = "";
-                        extension = "png";
-                        break;
-                    default:
-                        fileName = "Artwork";
-                        extension = "jpg";
-                        break;
-                }
-                fileName = ImageId + fileName;
-                string imageUrl = Url.Replace(LogoSize.t_thumb.ToString(), logoSize.ToString()).Replace("jpg", extension);
-
-                using (var s = client.GetStreamAsync("https:" + imageUrl))
-                {
-                    if (!Directory.Exists(LogoPath)) { Directory.CreateDirectory(LogoPath); }
-                    using (var fs = new FileStream(Path.Combine(LogoPath, fileName + "." + extension), FileMode.OpenOrCreate))
-                    {
-                        s.Result.CopyTo(fs);
-                    }
-                }
-            }
-        }
-
-        private enum LogoSize
-        {
-            t_thumb,
-            t_logo_med,
-            t_original
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Collections.cs

@@ -7,18 +7,12 @@ namespace gaseous_server.Classes.Metadata
 {
 	public class Collections
     {
-        const string fieldList = "fields checksum,created_at,games,name,slug,updated_at,url;";
+        const string fieldList = "fields as_child_relations,as_parent_relations,checksum,created_at,games,name,slug,type,updated_at,url;";
 
         public Collections()
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static Collection? GetCollections(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<Collection> GetObjectFromServer(string WhereClause)
         {
             // get Collections metadata
-            var results = await igdb.QueryAsync<Collection>(IGDBClient.Endpoints.Collections, query: fieldList + " " + WhereClause + ";");
+            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/Communications.cs

@@ -0,0 +1,595 @@
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Net;
+using Humanizer;
+using IGDB;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using RestEase;
+
+namespace gaseous_server.Classes.Metadata
+{
+    /// <summary>
+    /// Handles all metadata API communications
+    /// </summary>
+    public class Communications
+    {
+        static Communications()
+        {
+            var handler = new HttpClientHandler();
+            handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+            client = new HttpClient(handler);
+
+            client.DefaultRequestHeaders.Add("Accept-Encoding", "gzip");
+            client.DefaultRequestHeaders.Add("Accept-Encoding", "deflate");
+        }
+
+        private static IGDBClient igdb = new IGDBClient(
+                    // Found in Twitch Developer portal for your app
+                    Config.IGDB.ClientId,
+                    Config.IGDB.Secret
+                );
+
+        private static HttpClient client = new HttpClient();
+
+        /// <summary>
+        /// Configure metadata API communications
+        /// </summary>
+        public static HasheousClient.Models.MetadataModel.MetadataSources MetadataSource
+        {
+            get
+            {
+                return _MetadataSource;
+            }
+            set
+            {
+                _MetadataSource = value;
+
+                switch (value)
+                {
+                    case HasheousClient.Models.MetadataModel.MetadataSources.IGDB:
+                        // set rate limiter avoidance values
+                        RateLimitAvoidanceWait = 1500;
+                        RateLimitAvoidanceThreshold = 3;
+                        RateLimitAvoidancePeriod = 1;
+
+                        // set rate limiter recovery values
+                        RateLimitRecoveryWaitTime = 10000;
+
+                        break;
+                    default:
+                        // leave all values at default
+                        break;
+                }
+            }
+        }
+        private static HasheousClient.Models.MetadataModel.MetadataSources _MetadataSource = HasheousClient.Models.MetadataModel.MetadataSources.None;
+
+        // rate limit avoidance - what can we do to ensure that rate limiting is avoided?
+        // these values affect all communications
+
+        /// <summary>
+        /// How long to wait to avoid hitting an API rate limiter
+        /// </summary>
+        private static int RateLimitAvoidanceWait = 2000;
+
+        /// <summary>
+        /// How many API calls in the period are allowed before we start introducing a wait
+        /// </summary>
+        private static int RateLimitAvoidanceThreshold = 80;
+
+        /// <summary>
+        /// A counter of API calls since the beginning of the period
+        /// </summary>
+        private static int RateLimitAvoidanceCallCount = 0;
+
+        /// <summary>
+        /// How large the period (in seconds) to measure API call counts against
+        /// </summary>
+        private static int RateLimitAvoidancePeriod = 60;
+
+        /// <summary>
+        /// The start of the rate limit avoidance period
+        /// </summary>
+        private static DateTime RateLimitAvoidanceStartTime = DateTime.UtcNow;
+
+        /// <summary>
+        /// Used to determine if we're already in rate limit avoidance mode - always query "InRateLimitAvoidanceMode"
+        /// for up to date mode status.
+        /// This bool is used to track status changes and should not be relied upon for current status.
+        /// </summary>
+        private static bool InRateLimitAvoidanceModeStatus = false;
+
+        /// <summary>
+        /// Determine if we're in rate limit avoidance mode.
+        /// </summary>
+        private static bool InRateLimitAvoidanceMode
+        {
+            get
+            {
+                if (RateLimitAvoidanceStartTime.AddSeconds(RateLimitAvoidancePeriod) <= DateTime.UtcNow)
+                {
+                    // avoidance period has expired - reset
+                    RateLimitAvoidanceCallCount = 0;
+                    RateLimitAvoidanceStartTime = DateTime.UtcNow;
+
+                    return false;
+                }
+                else
+                {
+                    // we're in the avoidance period
+                    if (RateLimitAvoidanceCallCount > RateLimitAvoidanceThreshold)
+                    {
+                        // the number of call counts indicates we should throttle things a bit
+                        if (InRateLimitAvoidanceModeStatus == false)
+                        {
+                            Logging.Log(Logging.LogType.Information, "API Connection", "Entered rate limit avoidance period, API calls will be throttled by " + RateLimitAvoidanceWait + " milliseconds.");
+                            InRateLimitAvoidanceModeStatus = true;
+                        }
+                        return true;
+                    }
+                    else
+                    {
+                        // still in full speed mode - no throttle required
+                        if (InRateLimitAvoidanceModeStatus == true)
+                        {
+                            Logging.Log(Logging.LogType.Information, "API Connection", "Exited rate limit avoidance period, API call rate is returned to full speed.");
+                            InRateLimitAvoidanceModeStatus = false;
+                        }
+                        return false;
+                    }
+                }
+            }
+        }
+
+        // rate limit handling - how long to wait to allow the server to recover and try again
+        // these values affect ALL communications if a 429 response code is received
+
+        /// <summary>
+        /// How long to wait (in milliseconds) if a 429 status code is received before trying again
+        /// </summary>
+        private static int RateLimitRecoveryWaitTime = 10000;
+
+        /// <summary>
+        /// The time when normal communications can attempt to be resumed
+        /// </summary>
+        private static DateTime RateLimitResumeTime = DateTime.UtcNow.AddMinutes(5 * -1);
+
+        // rate limit retry - how many times to retry before aborting
+        private int RetryAttempts = 0;
+        private int RetryAttemptsMax = 3;
+
+        /// <summary>
+        /// Request data from the metadata API
+        /// </summary>
+        /// <typeparam name="T">Type of object to return</typeparam>
+        /// <param name="Endpoint">API endpoint segment to use</param>
+        /// <param name="Fields">Fields to request from the API</param>
+        /// <param name="Query">Selection criteria for data to request</param>
+        /// <returns></returns>
+        public async Task<T[]?> APIComm<T>(string Endpoint, string Fields, string Query)
+        {
+            switch (_MetadataSource)
+            {
+                case HasheousClient.Models.MetadataModel.MetadataSources.None:
+                    return null;
+                case HasheousClient.Models.MetadataModel.MetadataSources.IGDB:
+                    return await IGDBAPI<T>(Endpoint, Fields, Query);
+                default:
+                    return null;
+            }
+        }
+
+        private async Task<T[]> IGDBAPI<T>(string Endpoint, string Fields, string Query)
+        {
+            Logging.Log(Logging.LogType.Debug, "API Connection", "Accessing API for endpoint: " + Endpoint);
+
+            if (RateLimitResumeTime > DateTime.UtcNow)
+            {
+                Logging.Log(Logging.LogType.Information, "API Connection", "IGDB rate limit hit. Pausing API communications until " + RateLimitResumeTime.ToString() + ". Attempt " + RetryAttempts + " of " + RetryAttemptsMax + " retries.");
+                Thread.Sleep(RateLimitRecoveryWaitTime);
+            }
+
+            try
+            {
+                if (InRateLimitAvoidanceMode == true)
+                {
+                    // sleep for a moment to help avoid hitting the rate limiter
+                    Logging.Log(Logging.LogType.Information, "API Connection: Endpoint:" + Endpoint, "IGDB rate limit hit. Pausing API communications for " + RateLimitAvoidanceWait + " milliseconds to avoid rate limiter.");
+                    Thread.Sleep(RateLimitAvoidanceWait);
+                }
+
+                // perform the actual API call
+                var results = await igdb.QueryAsync<T>(Endpoint, query: Fields + " " + Query + ";");
+
+                // increment rate limiter avoidance call count
+                RateLimitAvoidanceCallCount += 1;
+
+                return results;
+            }
+            catch (ApiException apiEx)
+            {
+                switch (apiEx.StatusCode)
+                {
+                    case HttpStatusCode.TooManyRequests:
+                        if (RetryAttempts >= RetryAttemptsMax)
+                        {
+                            Logging.Log(Logging.LogType.Warning, "API Connection", "IGDB rate limiter attempts expired. Aborting.", apiEx);
+                            throw;
+                        }
+                        else
+                        {
+                            Logging.Log(Logging.LogType.Information, "API Connection", "IGDB API rate limit hit while accessing endpoint " + Endpoint, apiEx);
+
+                            RetryAttempts += 1;
+
+                            return await IGDBAPI<T>(Endpoint, Fields, Query);
+                        }
+
+                    case HttpStatusCode.Unauthorized:
+                        Logging.Log(Logging.LogType.Information, "API Connection", "IGDB API unauthorised error while accessing endpoint " + Endpoint + ". Waiting " + RateLimitAvoidanceWait + " milliseconds and resetting IGDB client.", apiEx);
+
+                        Thread.Sleep(RateLimitAvoidanceWait);
+
+                        igdb = new IGDBClient(
+                            // Found in Twitch Developer portal for your app
+                            Config.IGDB.ClientId,
+                            Config.IGDB.Secret
+                        );
+
+                        RetryAttempts += 1;
+
+                        return await IGDBAPI<T>(Endpoint, Fields, Query);
+
+                    default:
+                        Logging.Log(Logging.LogType.Warning, "API Connection", "Exception when accessing endpoint " + Endpoint, apiEx);
+                        throw;
+                }
+            }
+            catch (Exception ex)
+            {
+                Logging.Log(Logging.LogType.Warning, "API Connection", "Exception when accessing endpoint " + Endpoint, ex);
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Download from the specified uri
+        /// </summary>
+        /// <param name="uri">The uri to download from</param>
+        /// <param name="DestinationFile">The file name and path the download should be stored as</param>
+        public Task<bool?> DownloadFile(Uri uri, string DestinationFile)
+        {
+            var result = _DownloadFile(uri, DestinationFile);
+
+            return result;
+        }
+
+        private async Task<bool?> _DownloadFile(Uri uri, string DestinationFile)
+        {
+            string DestinationDirectory = new FileInfo(DestinationFile).Directory.FullName;
+            if (!Directory.Exists(DestinationDirectory))
+            {
+                Directory.CreateDirectory(DestinationDirectory);
+            }
+
+            Logging.Log(Logging.LogType.Information, "Communications", "Downloading from " + uri.ToString() + " to " + DestinationFile);
+
+            try
+            {
+                using (HttpResponseMessage response = client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead).Result)
+                {
+                    response.EnsureSuccessStatusCode();
+
+                    using (Stream contentStream = await response.Content.ReadAsStreamAsync(), fileStream = new FileStream(DestinationFile, FileMode.Create, FileAccess.Write, FileShare.None, 8192, true))
+                    {
+                        var totalRead = 0L;
+                        var totalReads = 0L;
+                        var buffer = new byte[8192];
+                        var isMoreToRead = true;
+
+                        do
+                        {
+                            var read = await contentStream.ReadAsync(buffer, 0, buffer.Length);
+                            if (read == 0)
+                            {
+                                isMoreToRead = false;
+                            }
+                            else
+                            {
+                                await fileStream.WriteAsync(buffer, 0, read);
+
+                                totalRead += read;
+                                totalReads += 1;
+
+                                if (totalReads % 2000 == 0)
+                                {
+                                    Console.WriteLine(string.Format("total bytes downloaded so far: {0:n0}", totalRead));
+                                }
+                            }
+                        }
+                        while (isMoreToRead);
+                    }
+                }
+
+                return true;
+            }
+            catch (HttpRequestException ex)
+            {
+                if (ex.StatusCode == HttpStatusCode.NotFound)
+                {
+                    if (File.Exists(DestinationFile))
+                    {
+                        FileInfo fi = new FileInfo(DestinationFile);
+                        if (fi.Length == 0)
+                        {
+                            File.Delete(DestinationFile);
+                        }
+                    }
+                }
+
+                Logging.Log(Logging.LogType.Warning, "Download Images", "Error downloading file: ", ex);
+            }
+
+            return false;
+        }
+
+        public async Task<string> GetSpecificImageFromServer(string ImagePath, string ImageId, IGDBAPI_ImageSize size, List<IGDBAPI_ImageSize>? FallbackSizes = null)
+        {
+            string returnPath = "";
+
+            // check for artificial sizes first
+            switch (size)
+            {
+                case IGDBAPI_ImageSize.screenshot_small:
+                case IGDBAPI_ImageSize.screenshot_thumb:
+                    string BasePath = Path.Combine(ImagePath, size.ToString());
+                    if (!Directory.Exists(BasePath))
+                    {
+                        Directory.CreateDirectory(BasePath);
+                    }
+                    returnPath = Path.Combine(BasePath, ImageId + ".jpg");
+                    if (!File.Exists(returnPath))
+                    {
+                        // get original size image and resize
+                        string originalSizePath = await GetSpecificImageFromServer(ImagePath, ImageId, IGDBAPI_ImageSize.original, null);
+
+                        int width = 0;
+                        int height = 0;
+
+                        switch (size)
+                        {
+                            case IGDBAPI_ImageSize.screenshot_small:
+                                // 235x128
+                                width = 235;
+                                height = 128;
+                                break;
+
+                            case IGDBAPI_ImageSize.screenshot_thumb:
+                                // 165x90
+                                width = 165;
+                                height = 90;
+                                break;
+
+                        }
+
+                        using (var image = new ImageMagick.MagickImage(originalSizePath))
+                        {
+                            image.Resize(width, height);
+                            image.Strip();
+                            image.Write(returnPath);
+                        }
+                    }
+
+                    break;
+
+                default:
+                    // these sizes are IGDB native
+                    if (RateLimitResumeTime > DateTime.UtcNow)
+                    {
+                        Logging.Log(Logging.LogType.Information, "API Connection", "IGDB rate limit hit. Pausing API communications until " + RateLimitResumeTime.ToString() + ". Attempt " + RetryAttempts + " of " + RetryAttemptsMax + " retries.");
+                        Thread.Sleep(RateLimitRecoveryWaitTime);
+                    }
+
+                    if (InRateLimitAvoidanceMode == true)
+                    {
+                        // sleep for a moment to help avoid hitting the rate limiter
+                        Logging.Log(Logging.LogType.Information, "API Connection: Fetch Image", "IGDB rate limit hit. Pausing API communications for " + RateLimitAvoidanceWait + " milliseconds to avoid rate limiter.");
+                        Thread.Sleep(RateLimitAvoidanceWait);
+                    }
+
+                    Communications comms = new Communications();
+                    List<IGDBAPI_ImageSize> imageSizes = new List<IGDBAPI_ImageSize>
+                    {
+                        size
+                    };
+
+                    // get the image
+                    try
+                    {
+                        returnPath = Path.Combine(ImagePath, size.ToString(), ImageId + ".jpg");
+
+                        // fail early if the file is already downloaded
+                        if (!File.Exists(returnPath))
+                        {
+                            await comms.IGDBAPI_GetImage(imageSizes, ImageId, ImagePath);
+                        }
+
+                    }
+                    catch (HttpRequestException ex)
+                    {
+                        if (ex.StatusCode == HttpStatusCode.NotFound)
+                        {
+                            Logging.Log(Logging.LogType.Information, "Image Download", "Image not found, trying a different size.");
+
+                            if (FallbackSizes != null)
+                            {
+                                foreach (Communications.IGDBAPI_ImageSize imageSize in FallbackSizes)
+                                {
+                                    returnPath = await GetSpecificImageFromServer(ImagePath, ImageId, imageSize, null);
+                                }
+                            }
+                        }
+                    }
+
+                    // increment rate limiter avoidance call count
+                    RateLimitAvoidanceCallCount += 1;
+
+                    break;
+            }
+
+            return returnPath;
+        }
+
+        public static T? GetSearchCache<T>(string SearchFields, string SearchString)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM SearchCache WHERE SearchFields = @searchfields AND SearchString = @searchstring;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "searchfields", SearchFields },
+                { "searchstring", SearchString }
+            };
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+            if (data.Rows.Count > 0)
+            {
+                // cache hit
+                string rawString = data.Rows[0]["Content"].ToString();
+                T ReturnValue = Newtonsoft.Json.JsonConvert.DeserializeObject<T>(rawString);
+                if (ReturnValue != null)
+                {
+                    Logging.Log(Logging.LogType.Information, "Search Cache", "Found search result in cache. Search string: " + SearchString);
+                    return ReturnValue;
+                }
+                else
+                {
+                    Logging.Log(Logging.LogType.Information, "Search Cache", "Search result not found in cache.");
+                    return default;
+                }
+            }
+            else
+            {
+                // cache miss
+                Logging.Log(Logging.LogType.Information, "Search Cache", "Search result not found in cache.");
+                return default;
+            }
+        }
+
+        public static void SetSearchCache<T>(string SearchFields, string SearchString, T SearchResult)
+        {
+            Logging.Log(Logging.LogType.Information, "Search Cache", "Storing search results in cache. Search string: " + SearchString);
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "INSERT INTO SearchCache (SearchFields, SearchString, Content, LastSearch) VALUES (@searchfields, @searchstring, @content, @lastsearch);";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "searchfields", SearchFields },
+                { "searchstring", SearchString },
+                { "content", Newtonsoft.Json.JsonConvert.SerializeObject(SearchResult) },
+                { "lastsearch", DateTime.UtcNow }
+            };
+            db.ExecuteNonQuery(sql, dbDict);
+        }
+
+        /// <summary>
+        /// See https://api-docs.igdb.com/?javascript#images for more information about the image url structure
+        /// </summary>
+        /// <param name="ImageId"></param>
+        /// <param name="outputPath">The path to save the downloaded files to
+        public async Task IGDBAPI_GetImage(List<IGDBAPI_ImageSize> ImageSizes, string ImageId, string OutputPath)
+        {
+            string urlTemplate = "https://images.igdb.com/igdb/image/upload/t_{size}/{hash}.jpg";
+
+            foreach (IGDBAPI_ImageSize ImageSize in ImageSizes)
+            {
+                string url = urlTemplate.Replace("{size}", Common.GetDescription(ImageSize)).Replace("{hash}", ImageId);
+                string newOutputPath = Path.Combine(OutputPath, Common.GetDescription(ImageSize));
+                string OutputFile = ImageId + ".jpg";
+                string fullPath = Path.Combine(newOutputPath, OutputFile);
+
+                await _DownloadFile(new Uri(url), fullPath);
+            }
+        }
+
+        public enum IGDBAPI_ImageSize
+        {
+            /// <summary>
+            /// 90x128 Fit
+            /// </summary>
+            [Description("cover_small")]
+            cover_small,
+
+            /// <summary>
+            /// 264x374 Fit
+            /// </summary>
+            [Description("cover_big")]
+            cover_big,
+
+            /// <summary>
+            /// 165x90 Lfill, Centre gravity - resized by Gaseous and is not a real IGDB size
+            /// </summary>
+            [Description("screenshot_thumb")]
+            screenshot_thumb,
+
+            /// <summary>
+            /// 235x128 Lfill, Centre gravity - resized by Gaseous and is not a real IGDB size
+            /// </summary>
+            [Description("screenshot_small")]
+            screenshot_small,
+
+            /// <summary>
+            /// 589x320 Lfill, Centre gravity
+            /// </summary>
+            [Description("screenshot_med")]
+            screenshot_med,
+
+            /// <summary>
+            /// 889x500 Lfill, Centre gravity
+            /// </summary>
+            [Description("screenshot_big")]
+            screenshot_big,
+
+            /// <summary>
+            /// 1280x720 Lfill, Centre gravity
+            /// </summary>
+            [Description("screenshot_huge")]
+            screenshot_huge,
+
+            /// <summary>
+            /// 284x160 Fit
+            /// </summary>
+            [Description("logo_med")]
+            logo_med,
+
+            /// <summary>
+            /// 90x90 Thumb, Centre gravity
+            /// </summary>
+            [Description("thumb")]
+            thumb,
+
+            /// <summary>
+            /// 35x35 Thumb, Centre gravity
+            /// </summary>
+            [Description("micro")]
+            micro,
+
+            /// <summary>
+            /// 1280x720 Fit, Centre gravity
+            /// </summary>
+            [Description("720p")]
+            r720p,
+
+            /// <summary>
+            /// 1920x1080 Fit, Centre gravity
+            /// </summary>
+            [Description("1080p")]
+            r1080p,
+
+            /// <summary>
+            /// The originally uploaded image
+            /// </summary>
+            [Description("original")]
+            original
+        }
+    }
+}

gaseous-server/Classes/Metadata/Company.cs

@@ -12,12 +12,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static Company? GetCompanies(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -111,7 +105,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<Company> GetObjectFromServer(string WhereClause)
         {
             // get Companies metadata
-            var results = await igdb.QueryAsync<Company>(IGDBClient.Endpoints.Companies, query: fieldList + " " + WhereClause + ";");
+            Communications comms = new Communications();
+            var results = await comms.APIComm<Company>(IGDBClient.Endpoints.Companies, fieldList, WhereClause);
             if (results.Length > 0)
             {
                 var result = results.First();

gaseous-server/Classes/Metadata/CompanyLogos.cs

@@ -13,13 +13,7 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
+        public static CompanyLogo? GetCompanyLogo(long? Id, string ImagePath)
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static CompanyLogo? GetCompanyLogo(long? Id, string LogoPath)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -27,18 +21,18 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<CompanyLogo> RetVal = _GetCompanyLogo(SearchUsing.id, Id, LogoPath);
+                Task<CompanyLogo> RetVal = _GetCompanyLogo(SearchUsing.id, Id, ImagePath);
                 return RetVal.Result;
             }
         }
 
-        public static CompanyLogo GetCompanyLogo(string Slug, string LogoPath)
+        public static CompanyLogo GetCompanyLogo(string Slug, string ImagePath)
         {
-            Task<CompanyLogo> RetVal = _GetCompanyLogo(SearchUsing.slug, Slug, LogoPath);
+            Task<CompanyLogo> RetVal = _GetCompanyLogo(SearchUsing.slug, Slug, ImagePath);
             return RetVal.Result;
         }
 
-        private static async Task<CompanyLogo> _GetCompanyLogo(SearchUsing searchUsing, object searchValue, string LogoPath)
+        private static async Task<CompanyLogo> _GetCompanyLogo(SearchUsing searchUsing, object searchValue, string ImagePath)
         {
             // check database first
             Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -70,7 +64,7 @@ namespace gaseous_server.Classes.Metadata
             switch (cacheStatus)
             {
                 case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                     if (returnValue != null)
                     {
                         Storage.NewCacheValue(returnValue);
@@ -80,10 +74,16 @@ namespace gaseous_server.Classes.Metadata
                 case Storage.CacheStatus.Expired:
                     try
                     {
-                        returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                         Storage.NewCacheValue(returnValue, true);
+
+                        // check if old value is different from the new value - only download if it's different
+                        CompanyLogo oldImage = Storage.GetCacheValue<CompanyLogo>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
                             forceImageDownload = true;
                         }
+                    }
                     catch (Exception ex)
                     {
                         Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
@@ -97,13 +97,14 @@ namespace gaseous_server.Classes.Metadata
                     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)
             {
-                if ((!File.Exists(Path.Combine(LogoPath, "Logo.jpg"))) || forceImageDownload == true)
+                Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Company logo download forced.");
-                {
+
-                    GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_thumb);
+                Communications comms = new Communications();
-                    GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med);
+                comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
-                }
             }
 
             return returnValue;
@@ -115,64 +116,15 @@ namespace gaseous_server.Classes.Metadata
             slug
         }
 
-        private static async Task<CompanyLogo?> GetObjectFromServer(string WhereClause, string LogoPath)
+        private static async Task<CompanyLogo> GetObjectFromServer(string WhereClause, string ImagePath)
-        {
-            // get CompanyLogo metadata
-            var results = await igdb.QueryAsync<CompanyLogo>(IGDBClient.Endpoints.CompanyLogos, query: fieldList + " " + WhereClause + ";");
-            if (results.Length > 0)
         {
+            // get Artwork metadata
+            Communications comms = new Communications();
+            var results = await comms.APIComm<CompanyLogo>(IGDBClient.Endpoints.CompanyLogos, fieldList, WhereClause);
             var result = results.First();
 
-                GetImageFromServer(result.Url, LogoPath, LogoSize.t_thumb);
-                GetImageFromServer(result.Url, LogoPath, LogoSize.t_logo_med);
-
             return result;
         }
-            else
-            {
-                return null;
-            }
-        }
-
-        private static void GetImageFromServer(string Url, string LogoPath, LogoSize logoSize)
-        {
-            using (var client = new HttpClient())
-            {
-                string fileName = "Logo.jpg";
-                string extension = "jpg";
-                switch (logoSize)
-                {
-                    case LogoSize.t_thumb:
-                        fileName = "Logo_Thumb";
-                        extension = "jpg";
-                        break;
-                    case LogoSize.t_logo_med:
-                        fileName = "Logo_Medium";
-                        extension = "png";
-                        break;
-                    default:
-                        fileName = "Logo";
-                        extension = "jpg";
-                        break;
-                }
-                string imageUrl = Url.Replace(LogoSize.t_thumb.ToString(), logoSize.ToString()).Replace("jpg", extension);
-
-                using (var s = client.GetStreamAsync("https:" + imageUrl))
-                {
-                    if (!Directory.Exists(LogoPath)) { Directory.CreateDirectory(LogoPath); }
-                    using (var fs = new FileStream(Path.Combine(LogoPath, fileName + "." + extension), FileMode.OpenOrCreate))
-                    {
-                        s.Result.CopyTo(fs);
-                    }
-                }
-            }
-        }
-
-        private enum LogoSize
-        {
-            t_thumb,
-            t_logo_med
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Covers.cs

@@ -1,25 +1,21 @@
 using System;
+using System.Net;
 using IGDB;
 using IGDB.Models;
+using Microsoft.CodeAnalysis.Elfie.Model.Strings;
 
 
 namespace gaseous_server.Classes.Metadata
 {
     public class Covers
     {
-        const string fieldList = "fields alpha_channel,animated,checksum,game,height,image_id,url,width;";
+        const string fieldList = "fields alpha_channel,animated,checksum,game,game_localization,height,image_id,url,width;";
 
         public Covers()
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
+        public static Cover? GetCover(long? Id, string ImagePath, bool GetImages)
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static Cover? GetCover(long? Id, string LogoPath)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -27,18 +23,18 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Cover> RetVal = _GetCover(SearchUsing.id, Id, LogoPath);
+                Task<Cover> RetVal = _GetCover(SearchUsing.id, Id, ImagePath, GetImages);
                 return RetVal.Result;
             }
         }
 
-        public static Cover GetCover(string Slug, string LogoPath)
+        public static Cover GetCover(string Slug, string ImagePath, bool GetImages)
         {
-            Task<Cover> RetVal = _GetCover(SearchUsing.slug, Slug, LogoPath);
+            Task<Cover> RetVal = _GetCover(SearchUsing.slug, Slug, ImagePath, GetImages);
             return RetVal.Result;
         }
 
-        private static async Task<Cover> _GetCover(SearchUsing searchUsing, object searchValue, string LogoPath)
+        private static async Task<Cover> _GetCover(SearchUsing searchUsing, object searchValue, string ImagePath, bool GetImages = true)
         {
             // check database first
             Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -67,20 +63,27 @@ namespace gaseous_server.Classes.Metadata
 
             Cover returnValue = new Cover();
             bool forceImageDownload = false;
+            ImagePath = Path.Combine(ImagePath, "Covers");
             switch (cacheStatus)
             {
                 case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                     Storage.NewCacheValue(returnValue);
                     forceImageDownload = true;
                     break;
                 case Storage.CacheStatus.Expired:
                     try
                     {
-                        returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                         Storage.NewCacheValue(returnValue, true);
+
+                        // check if old value is different from the new value - only download if it's different
+                        Cover oldCover = Storage.GetCacheValue<Cover>(returnValue, "id", (long)searchValue);
+                        if (oldCover.ImageId != returnValue.ImageId)
+                        {
                             forceImageDownload = true;
                         }
+                    }
                     catch (Exception ex)
                     {
                         Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
@@ -94,11 +97,30 @@ namespace gaseous_server.Classes.Metadata
                     throw new Exception("How did you get here?");
             }
 
-            if ((!File.Exists(Path.Combine(LogoPath, "Cover.jpg"))) || forceImageDownload == true)
+            string localFile = Path.Combine(ImagePath, Communications.IGDBAPI_ImageSize.original.ToString(), returnValue.ImageId + ".jpg");
+            if (GetImages == true)
             {
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_thumb, returnValue.ImageId);
+                if ((!File.Exists(localFile)) || forceImageDownload == true)
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med, returnValue.ImageId);
+                {
-                GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_original, returnValue.ImageId);
+                    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);
+                        }
+                    }
+                }
             }
 
             return returnValue;
@@ -110,63 +132,15 @@ namespace gaseous_server.Classes.Metadata
             slug
         }
 
-        private static async Task<Cover> GetObjectFromServer(string WhereClause, string LogoPath)
+        private static async Task<Cover> GetObjectFromServer(string WhereClause, string ImagePath)
         {
             // get Cover metadata
-            var results = await igdb.QueryAsync<Cover>(IGDBClient.Endpoints.Covers, query: fieldList + " " + WhereClause + ";");
+            Communications comms = new Communications();
+            var results = await comms.APIComm<Cover>(IGDBClient.Endpoints.Covers, fieldList, WhereClause);
             var result = results.First();
 
-            //GetImageFromServer(result.Url, LogoPath, LogoSize.t_thumb, result.ImageId);
-            //GetImageFromServer(result.Url, LogoPath, LogoSize.t_logo_med, result.ImageId);
-            GetImageFromServer(result.Url, LogoPath, LogoSize.t_original, result.ImageId);
-
             return result;
         }
-
-        private static void GetImageFromServer(string Url, string LogoPath, LogoSize logoSize, string ImageId)
-        {
-            using (var client = new HttpClient())
-            {
-                string fileName = "Cover.jpg";
-                string extension = "jpg";
-                switch (logoSize)
-                {
-                    case LogoSize.t_thumb:
-                        fileName = "Cover_Thumb";
-                        extension = "jpg";
-                        break;
-                    case LogoSize.t_logo_med:
-                        fileName = "Cover_Medium";
-                        extension = "png";
-                        break;
-                    case LogoSize.t_original:
-                        fileName = "Cover";
-                        extension = "png";
-                        break;
-                    default:
-                        fileName = "Cover";
-                        extension = "jpg";
-                        break;
-                }
-                string imageUrl = Url.Replace(LogoSize.t_thumb.ToString(), logoSize.ToString()).Replace("jpg", extension);
-
-                using (var s = client.GetStreamAsync("https:" + imageUrl))
-                {
-                    if (!Directory.Exists(LogoPath)) { Directory.CreateDirectory(LogoPath); }
-                    using (var fs = new FileStream(Path.Combine(LogoPath, fileName + "." + extension), FileMode.OpenOrCreate))
-                    {
-                        s.Result.CopyTo(fs);
-                    }
-                }
-            }
-        }
-
-        private enum LogoSize
-        {
-            t_thumb,
-            t_logo_med,
-            t_original
-        }
     }
 }
 

gaseous-server/Classes/Metadata/ExternalGames.cs

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static ExternalGame? GetExternalGames(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -106,7 +100,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<ExternalGame?> GetObjectFromServer(string WhereClause)
         {
             // get ExternalGames metadata
-            var results = await igdb.QueryAsync<ExternalGame>(IGDBClient.Endpoints.ExternalGames, query: fieldList + " " + WhereClause + ";");
+            Communications comms = new Communications();
+            var results = await comms.APIComm<ExternalGame>(IGDBClient.Endpoints.ExternalGames, fieldList, WhereClause);
             if (results.Length > 0)
             {
                 var result = results.First();

gaseous-server/Classes/Metadata/Franchises.cs

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static Franchise? GetFranchises(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<Franchise> GetObjectFromServer(string WhereClause)
         {
             // get FranchiseContentDescriptions metadata
-            var results = await igdb.QueryAsync<Franchise>(IGDBClient.Endpoints.Franchies, query: fieldList + " " + WhereClause + ";");
+            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

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static GameMode? GetGame_Modes(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<GameMode> GetObjectFromServer(string WhereClause)
         {
             // get Game_Modes metadata
-            var results = await igdb.QueryAsync<GameMode>(IGDBClient.Endpoints.GameModes, query: fieldList + " " + WhereClause + ";");
+            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

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static GameVideo? GetGame_Videos(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<GameVideo> GetObjectFromServer(string WhereClause)
         {
             // get Game_Videos metadata
-            var results = await igdb.QueryAsync<GameVideo>(IGDBClient.Endpoints.GameVideos, query: fieldList + " " + WhereClause + ";");
+            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,5 +1,6 @@
 using System;
 using System.Data;
+using gaseous_server.Models;
 using IGDB;
 using IGDB.Models;
 
@@ -7,7 +8,7 @@ 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,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;";
+        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,12 +21,6 @@ namespace gaseous_server.Classes.Metadata
             { }
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static Game? GetGame(long Id, bool getAllMetadata, bool followSubGames, bool forceRefresh)
         {
             if (Id == 0)
@@ -84,15 +79,17 @@ namespace gaseous_server.Classes.Metadata
                 if (cacheStatus == Storage.CacheStatus.Current) { cacheStatus = Storage.CacheStatus.Expired; }
             }
 
-            // set up where clause
             string WhereClause = "";
+            string searchField = "";
             switch (searchUsing)
             {
                 case SearchUsing.id:
                     WhereClause = "where id = " + searchValue;
+                    searchField = "id";
                     break;
                 case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
+                    WhereClause = "where slug = \"" + searchValue + "\"";
+                    searchField = "slug";
                     break;
                 default:
                     throw new Exception("Invalid search type");
@@ -104,35 +101,44 @@ namespace gaseous_server.Classes.Metadata
                 case Storage.CacheStatus.NotPresent:
                     returnValue = await GetObjectFromServer(WhereClause);
                     Storage.NewCacheValue(returnValue);
-                    UpdateSubClasses(returnValue, getAllMetadata, followSubGames);
+                    UpdateSubClasses(returnValue, getAllMetadata, followSubGames, forceRefresh);
                     return returnValue;
                 case Storage.CacheStatus.Expired:
                     try
                     {
                         returnValue = await GetObjectFromServer(WhereClause);
                         Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(returnValue, getAllMetadata, followSubGames);
+                        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);
+                        returnValue = Storage.GetCacheValue<Game>(returnValue, searchField, searchValue);
                     }
                     return returnValue;
                 case Storage.CacheStatus.Current:
-                    return Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
+                    returnValue = Storage.GetCacheValue<Game>(returnValue, searchField, 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)
+        private static void UpdateSubClasses(Game Game, bool getAllMetadata, bool followSubGames, bool forceRefresh)
         {
             // required metadata
-            if (Game.Cover != null)
+            // if (Game.Cover != null)
-            {
+            // {
-                Cover GameCover = Covers.GetCover(Game.Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game));
+            //     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)
             {
@@ -174,9 +180,6 @@ namespace gaseous_server.Classes.Metadata
                 }
             }
 
-            // optional metadata - usually downloaded as needed
-            if (getAllMetadata == true)
-            {
             if (Game.AgeRatings != null)
             {
                 foreach (long AgeRatingId in Game.AgeRatings.Ids)
@@ -184,7 +187,19 @@ namespace gaseous_server.Classes.Metadata
                     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)
@@ -197,7 +212,14 @@ namespace gaseous_server.Classes.Metadata
                 {
                     foreach (long ArtworkId in Game.Artworks.Ids)
                     {
-                        Artwork GameArtwork = Artworks.GetArtwork(ArtworkId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game));
+                        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);
+                        }
                     }
                 }
 
@@ -264,7 +286,14 @@ namespace gaseous_server.Classes.Metadata
                 {
                     foreach (long ScreenshotId in Game.Screenshots.Ids)
                     {
-                        Screenshot GameScreenshot = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game));
+                        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);
+                        }
                     }
                 }
 
@@ -287,46 +316,344 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<Game> GetObjectFromServer(string WhereClause)
         {
             // get Game metadata
-            var results = await igdb.QueryAsync<Game>(IGDBClient.Endpoints.Games, query: fieldList + " " + WhereClause + ";");
+            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>()
+            );
+
+            // 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);
+                        result.Cover = parentGame.Cover;
+                    }
+                }
+            }
+
+            // get missing metadata from parent if this is a port
+            if (result.Category == 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;
+                        }
+                    }
+                }
+            }
+
             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)
         {
-            Task<Game[]> games = _SearchForGame(SearchString, PlatformId, searchType);
+            // search local first
+            Logging.Log(Logging.LogType.Information, "Game Search", "Attempting local search of type '" + searchType.ToString() + "' for " + SearchString);
+            Task<Game[]> games = _SearchForGameDatabase(SearchString, PlatformId, searchType);
+            if (games.Result.Length == 0)
+            {
+                // fall back to online search
+                Logging.Log(Logging.LogType.Information, "Game Search", "Falling back to remote search of type '" + searchType.ToString() + "' for " + SearchString);
+                games = _SearchForGameRemote(SearchString, PlatformId, searchType);
+            }
             return games.Result;
         }
 
-        private static async Task<Game[]> _SearchForGame(string SearchString, long PlatformId, SearchType searchType)
+        private static async Task<Game[]> _SearchForGameDatabase(string SearchString, long PlatformId, SearchType searchType)
         {
-            string searchBody = "";
+            string whereClause = "";
-            searchBody += "fields id,name,slug,platforms,summary; ";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+
+            bool allowSearch = true;
             switch (searchType)
             {
                 case SearchType.searchNoPlatform:
-                    searchBody += "search \"" + SearchString + "\"; ";
+                    whereClause = "MATCH(`Name`) AGAINST (@gamename)";
+                    dbDict.Add("platformid", PlatformId);
+                    dbDict.Add("gamename", SearchString);
+
+                    allowSearch = AllowNoPlatformSearch;
                     break;
                 case SearchType.search:
-                    searchBody += "search \"" + SearchString + "\"; ";
+                    whereClause = "PlatformsId = @platformid AND MATCH(`Name`) AGAINST (@gamename)";
-                    searchBody += "where platforms = (" + PlatformId + ");";
+                    dbDict.Add("platformid", PlatformId);
+                    dbDict.Add("gamename", SearchString);
                     break;
                 case SearchType.wherefuzzy:
-                    searchBody += "where platforms = (" + PlatformId + ") & name ~ *\"" + SearchString + "\"*;";
+                    whereClause = "PlatformsId = @platformid AND `Name` LIKE @gamename";
+                    dbDict.Add("platformid", PlatformId);
+                    dbDict.Add("gamename", "%" + SearchString + "%");
                     break;
                 case SearchType.where:
-                    searchBody += "where platforms = (" + PlatformId + ") & name ~ \"" + SearchString + "\";";
+                    whereClause = "PlatformsId = @platformid AND `Name` = @gamename";
+                    dbDict.Add("platformid", PlatformId);
+                    dbDict.Add("gamename", SearchString);
                     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 + ";";
+
 
             // get Game metadata
-            var results = await igdb.QueryAsync<Game>(IGDBClient.Endpoints.Games, query: searchBody);
+            Game[]? results = new Game[0];
+            if (allowSearch == true)
+            {
+                List<Game> searchResults = new List<Game>();
+                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                DataTable data = db.ExecuteCMD(sql, dbDict);
+                foreach (DataRow row in data.Rows)
+                {
+                    Game game = new Game
+                    {
+                        Id = (long)row["Id"],
+                        Name = (string)Common.ReturnValueIfNull(row["Name"], ""),
+                        Slug = (string)Common.ReturnValueIfNull(row["Slug"], ""),
+                        Summary = (string)Common.ReturnValueIfNull(row["Summary"], "")
+                    };
+                    searchResults.Add(game);
+                }
+
+                results = searchResults.ToArray();
+            }
 
             return results;
         }
 
+        private static async Task<Game[]> _SearchForGameRemote(string SearchString, long PlatformId, SearchType searchType)
+        {
+            string searchBody = "";
+            string searchFields = "fields id,name,slug,platforms,summary; ";
+            bool allowSearch = true;
+            switch (searchType)
+            {
+                case SearchType.searchNoPlatform:
+                    searchBody = "search \"" + SearchString + "\"; ";
+
+                    allowSearch = AllowNoPlatformSearch;
+                    break;
+                case SearchType.search:
+                    searchBody = "search \"" + SearchString + "\"; where platforms = (" + PlatformId + ");";
+                    break;
+                case SearchType.wherefuzzy:
+                    searchBody = "where platforms = (" + PlatformId + ") & name ~ *\"" + SearchString + "\"*;";
+                    break;
+                case SearchType.where:
+                    searchBody = "where platforms = (" + PlatformId + ") & name ~ \"" + SearchString + "\";";
+                    break;
+            }
+
+            // check search cache
+            Game[]? games = Communications.GetSearchCache<Game[]?>(searchFields, searchBody);
+
+            if (games == null)
+            {
+                // cache miss
+                // get Game metadata
+                Communications comms = new Communications();
+                Game[]? results = new Game[0];
+                if (allowSearch == true)
+                {
+                    results = await comms.APIComm<Game>(IGDBClient.Endpoints.Games, searchFields, searchBody);
+
+                    Communications.SetSearchCache<Game[]?>(searchFields, searchBody, results);
+                }
+
+                return results;
+            }
+            else
+            {
+                return games.ToArray();
+            }
+        }
+
+        public static List<AvailablePlatformItem> GetAvailablePlatforms(string UserId, long GameId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = @"
+SELECT DISTINCT
+    Games_Roms.GameId,
+    Games_Roms.PlatformId,
+    Platform.`Name`,
+    User_RecentPlayedRoms.UserId AS MostRecentUserId,
+    User_RecentPlayedRoms.RomId AS MostRecentRomId,
+    CASE User_RecentPlayedRoms.IsMediaGroup
+        WHEN 0 THEN GMR.`Name`
+        WHEN 1 THEN 'Media Group'
+        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 'Media Group'
+        ELSE NULL
+    END AS `FavouriteRomName`,
+    User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup
+FROM
+    Games_Roms
+        LEFT JOIN
+    Platform ON Games_Roms.PlatformId = Platform.Id
+        LEFT JOIN
+    User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
+        AND User_RecentPlayedRoms.GameId = Games_Roms.GameId
+        AND User_RecentPlayedRoms.PlatformId = Games_Roms.PlatformId
+        LEFT JOIN
+    User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
+        AND User_GameFavouriteRoms.GameId = Games_Roms.GameId
+        AND User_GameFavouriteRoms.PlatformId = Games_Roms.PlatformId
+        LEFT JOIN
+    Games_Roms AS GMR ON GMR.Id = User_RecentPlayedRoms.RomId
+        LEFT JOIN
+    Games_Roms AS GFV ON GFV.Id = User_GameFavouriteRoms.RomId
+WHERE
+    Games_Roms.GameId = @gameid
+ORDER BY Platform.`Name`;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "gameid", GameId },
+                { "userid", UserId }
+            };
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            PlatformMapping platformMapping = new PlatformMapping();
+            List<AvailablePlatformItem> platforms = new List<AvailablePlatformItem>();
+            foreach (DataRow row in data.Rows)
+            {
+                IGDB.Models.Platform platform = Platforms.GetPlatform((long)row["PlatformId"]);
+                PlatformMapping.UserEmulatorConfiguration? emulatorConfiguration = platformMapping.GetUserEmulator(UserId, GameId, (long)platform.Id);
+
+                if (emulatorConfiguration == null)
+                {
+                    if (platform.Id != 0)
+                    {
+                        Models.PlatformMapping.PlatformMapItem platformMap = PlatformMapping.GetPlatformMap((long)platform.Id);
+                        emulatorConfiguration = new PlatformMapping.UserEmulatorConfiguration
+                        {
+                            EmulatorType = platformMap.WebEmulator.Type,
+                            Core = platformMap.WebEmulator.Core,
+                            EnableBIOSFiles = platformMap.EnabledBIOSHashes
+                        };
+                    }
+                }
+
+                long? LastPlayedRomId = null;
+                bool? LastPlayedIsMediagroup = false;
+                string? LastPlayedRomName = null;
+                if (row["MostRecentRomId"] != DBNull.Value)
+                {
+                    LastPlayedRomId = (long?)row["MostRecentRomId"];
+                    LastPlayedIsMediagroup = (bool)row["MostRecentRomIsMediaGroup"];
+                    LastPlayedRomName = (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"];
+                    FavouriteRomName = (string)row["FavouriteRomName"];
+                }
+
+                AvailablePlatformItem valuePair = new AvailablePlatformItem
+                {
+                    Id = platform.Id,
+                    Name = platform.Name,
+                    Category = platform.Category,
+                    emulatorConfiguration = emulatorConfiguration,
+                    LastPlayedRomId = LastPlayedRomId,
+                    LastPlayedRomIsMediagroup = LastPlayedIsMediagroup,
+                    LastPlayedRomName = LastPlayedRomName,
+                    FavouriteRomId = FavouriteRomId,
+                    FavouriteRomIsMediagroup = FavouriteRomIsMediagroup,
+                    FavouriteRomName = FavouriteRomName
+                };
+                platforms.Add(valuePair);
+            }
+
+            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 : IGDB.Models.Platform
+        {
+            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 enum SearchType
         {
             where = 0,
@@ -334,5 +661,54 @@ namespace gaseous_server.Classes.Metadata
             search = 2,
             searchNoPlatform = 3
         }
+
+        public class MinimalGameItem
+        {
+            public MinimalGameItem()
+            {
+
+            }
+
+            public MinimalGameItem(Game gameObject)
+            {
+                this.Id = gameObject.Id;
+                this.Name = gameObject.Name;
+                this.Slug = gameObject.Slug;
+                this.Summary = gameObject.Summary;
+                this.TotalRating = gameObject.TotalRating;
+                this.TotalRatingCount = gameObject.TotalRatingCount;
+                this.Cover = gameObject.Cover;
+                this.Artworks = gameObject.Artworks;
+                this.FirstReleaseDate = gameObject.FirstReleaseDate;
+
+                // compile age ratings
+                this.AgeRatings = new List<AgeRating>();
+                if (gameObject.AgeRatings != null)
+                {
+                    foreach (long ageRatingId in gameObject.AgeRatings.Ids)
+                    {
+                        AgeRating? rating = Classes.Metadata.AgeRatings.GetAgeRatings(ageRatingId);
+                        if (rating != null)
+                        {
+                            this.AgeRatings.Add(rating);
+                        }
+                    }
+                }
+            }
+
+            public long? Id { 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; }
+        }
     }
 }

gaseous-server/Classes/Metadata/Genres.cs

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static Genre? GetGenres(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<Genre> GetObjectFromServer(string WhereClause)
         {
             // get Genres metadata
-            var results = await igdb.QueryAsync<Genre>(IGDBClient.Endpoints.Genres, query: fieldList + " " + WhereClause + ";");
+            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

@@ -12,12 +12,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static InvolvedCompany? GetInvolvedCompanies(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -113,7 +107,8 @@ namespace gaseous_server.Classes.Metadata
             // get InvolvedCompanies metadata
             try
             {
-                var results = await igdb.QueryAsync<InvolvedCompany>(IGDBClient.Endpoints.InvolvedCompanies, query: fieldList + " " + WhereClause + ";");
+                Communications comms = new Communications();
+            var results = await comms.APIComm<InvolvedCompany>(IGDBClient.Endpoints.InvolvedCompanies, fieldList, WhereClause);
                 var result = results.First();
 
                 return result;

gaseous-server/Classes/Metadata/MultiplayerModes.cs

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static MultiplayerMode? GetGame_MultiplayerModes(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -103,7 +97,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<MultiplayerMode> GetObjectFromServer(string WhereClause)
         {
             // get Game_MultiplayerModes metadata
-            var results = await igdb.QueryAsync<MultiplayerMode>(IGDBClient.Endpoints.MultiplayerModes, query: fieldList + " " + WhereClause + ";");
+            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

@@ -13,13 +13,7 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
+        public static PlatformLogo? GetPlatformLogo(long? Id, string ImagePath)
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static PlatformLogo? GetPlatformLogo(long? Id, string LogoPath)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -27,18 +21,18 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<PlatformLogo> RetVal = _GetPlatformLogo(SearchUsing.id, Id, LogoPath);
+                Task<PlatformLogo> RetVal = _GetPlatformLogo(SearchUsing.id, Id, ImagePath);
                 return RetVal.Result;
             }
         }
 
-        public static PlatformLogo GetPlatformLogo(string Slug, string LogoPath)
+        public static PlatformLogo GetPlatformLogo(string Slug, string ImagePath)
         {
-            Task<PlatformLogo> RetVal = _GetPlatformLogo(SearchUsing.slug, Slug, LogoPath);
+            Task<PlatformLogo> RetVal = _GetPlatformLogo(SearchUsing.slug, Slug, ImagePath);
             return RetVal.Result;
         }
 
-        private static async Task<PlatformLogo> _GetPlatformLogo(SearchUsing searchUsing, object searchValue, string LogoPath)
+        private static async Task<PlatformLogo> _GetPlatformLogo(SearchUsing searchUsing, object searchValue, string ImagePath)
         {
             // check database first
             Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -70,7 +64,7 @@ namespace gaseous_server.Classes.Metadata
             switch (cacheStatus)
             {
                 case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                     if (returnValue != null)
                     {
                         Storage.NewCacheValue(returnValue);
@@ -80,10 +74,16 @@ namespace gaseous_server.Classes.Metadata
                 case Storage.CacheStatus.Expired:
                     try
                     {
-                        returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                         Storage.NewCacheValue(returnValue, true);
+                        
+                        // check if old value is different from the new value - only download if it's different
+                        PlatformLogo oldImage = Storage.GetCacheValue<PlatformLogo>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
                             forceImageDownload = true;
                         }
+                    }
                     catch (Exception ex)
                     {
                         Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
@@ -99,10 +99,14 @@ namespace gaseous_server.Classes.Metadata
 
             if (returnValue != null)
             {
-                if ((!File.Exists(Path.Combine(LogoPath, "Logo.jpg"))) || forceImageDownload == true)
+                // 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)
                 {
-                    GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_thumb);
+                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Platform logo download forced.");
-                    GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med);
+
+                    Communications comms = new Communications();
+                    comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
                 }
             }
 
@@ -115,64 +119,15 @@ namespace gaseous_server.Classes.Metadata
             slug
         }
 
-        private static async Task<PlatformLogo?> GetObjectFromServer(string WhereClause, string LogoPath)
+        private static async Task<PlatformLogo> GetObjectFromServer(string WhereClause, string ImagePath)
-        {
-            // get PlatformLogo metadata
-            var results = await igdb.QueryAsync<PlatformLogo>(IGDBClient.Endpoints.PlatformLogos, query: fieldList + " " + WhereClause + ";");
-            if (results.Length > 0)
         {
+            // get Artwork metadata
+            Communications comms = new Communications();
+            var results = await comms.APIComm<PlatformLogo>(IGDBClient.Endpoints.PlatformLogos, fieldList, WhereClause);
             var result = results.First();
 
-                GetImageFromServer(result.Url, LogoPath, LogoSize.t_thumb);
-                GetImageFromServer(result.Url, LogoPath, LogoSize.t_logo_med);
-
             return result;
         }
-            else
-            {
-                return null;
-            }
-        }
-
-        private static void GetImageFromServer(string Url, string LogoPath, LogoSize logoSize)
-        {
-            using (var client = new HttpClient())
-            {
-                string fileName = "Logo.jpg";
-                string extension = "jpg";
-                switch (logoSize)
-                {
-                    case LogoSize.t_thumb:
-                        fileName = "Logo_Thumb";
-                        extension = "jpg";
-                        break;
-                    case LogoSize.t_logo_med:
-                        fileName = "Logo_Medium";
-                        extension = "png";
-                        break;
-                    default:
-                        fileName = "Logo";
-                        extension = "jpg";
-                        break;
-                }
-                string imageUrl = Url.Replace(LogoSize.t_thumb.ToString(), logoSize.ToString()).Replace("jpg", extension);
-
-                using (var s = client.GetStreamAsync("https:" + imageUrl))
-                {
-                    if (!Directory.Exists(LogoPath)) { Directory.CreateDirectory(LogoPath); }
-                    using (var fs = new FileStream(Path.Combine(LogoPath, fileName + "." + extension), FileMode.OpenOrCreate))
-                    {
-                        s.Result.CopyTo(fs);
-                    }
-                }
-            }
-        }
-
-        private enum LogoSize
-        {
-            t_thumb,
-            t_logo_med
-        }
 	}
 }
 

gaseous-server/Classes/Metadata/PlatformVersions.cs

@@ -13,13 +13,7 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
+        public static PlatformVersion? GetPlatformVersion(long Id, Platform ParentPlatform, bool GetImages = false)
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static PlatformVersion? GetPlatformVersion(long Id, Platform ParentPlatform)
         {
             if (Id == 0)
             {
@@ -27,18 +21,18 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.id, Id, ParentPlatform);
+                Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.id, Id, ParentPlatform, GetImages);
                 return RetVal.Result;
             }
         }
 
-        public static PlatformVersion GetPlatformVersion(string Slug, Platform ParentPlatform)
+        public static PlatformVersion GetPlatformVersion(string Slug, Platform ParentPlatform, bool GetImages = false)
         {
-            Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.slug, Slug, ParentPlatform);
+            Task<PlatformVersion> RetVal = _GetPlatformVersion(SearchUsing.slug, Slug, ParentPlatform, GetImages);
             return RetVal.Result;
         }
 
-        private static async Task<PlatformVersion> _GetPlatformVersion(SearchUsing searchUsing, object searchValue, Platform ParentPlatform)
+        private static async Task<PlatformVersion> _GetPlatformVersion(SearchUsing searchUsing, object searchValue, Platform ParentPlatform, bool GetImages)
         {
             // check database first
             Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -73,7 +67,7 @@ namespace gaseous_server.Classes.Metadata
                     if (returnValue != null)
                     {
                         Storage.NewCacheValue(returnValue);
-                        UpdateSubClasses(ParentPlatform, returnValue);
+                        UpdateSubClasses(ParentPlatform, returnValue, GetImages);
                     }
                     return returnValue;
                 case Storage.CacheStatus.Expired:
@@ -81,7 +75,7 @@ namespace gaseous_server.Classes.Metadata
                     {
                         returnValue = await GetObjectFromServer(WhereClause);
                         Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(ParentPlatform, returnValue);
+                        UpdateSubClasses(ParentPlatform, returnValue, GetImages);
                     }
                     catch (Exception ex)
                     {
@@ -96,12 +90,22 @@ namespace gaseous_server.Classes.Metadata
             }
         }
 
-        private static void UpdateSubClasses(Platform ParentPlatform, PlatformVersion platformVersion)
+        private static void UpdateSubClasses(Platform ParentPlatform, PlatformVersion platformVersion, bool GetImages)
+        {
+            if (GetImages == true)
             {
                 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
@@ -113,7 +117,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<PlatformVersion?> GetObjectFromServer(string WhereClause)
         {
             // get PlatformVersion metadata
-            var results = await igdb.QueryAsync<PlatformVersion>(IGDBClient.Endpoints.PlatformVersions, query: fieldList + " " + WhereClause + ";");
+            Communications comms = new Communications();
+            var results = await comms.APIComm<PlatformVersion>(IGDBClient.Endpoints.PlatformVersions, fieldList, WhereClause);
             if (results.Length > 0)
             {
                 var result = results.First();

gaseous-server/Classes/Metadata/Platforms.cs

@@ -15,13 +15,7 @@ namespace gaseous_server.Classes.Metadata
 
         }
 
-        private static IGDBClient igdb = new IGDBClient(
+        public static Platform? GetPlatform(long Id, bool forceRefresh = false, bool GetImages = false)
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static Platform? GetPlatform(long Id, bool forceRefresh = false)
         {
             if (Id == 0)
             {
@@ -45,18 +39,26 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Platform> RetVal = _GetPlatform(SearchUsing.id, Id, forceRefresh);
+                try
-                return RetVal.Result;
-            }
-        }
-
-		public static Platform GetPlatform(string Slug, bool forceRefresh = false)
                 {
-			Task<Platform> RetVal = _GetPlatform(SearchUsing.slug, Slug, forceRefresh);
+                    Task<Platform> RetVal = _GetPlatform(SearchUsing.id, Id, forceRefresh, GetImages);
+                    return RetVal.Result;
+                }
+                catch (Exception ex)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Metadata", "An error occurred fetching Platform Id " + Id, ex);
+                    return null;
+                }
+            }
+        }
+
+        public static Platform GetPlatform(string Slug, bool forceRefresh = false, bool GetImages = false)
+        {
+            Task<Platform> RetVal = _GetPlatform(SearchUsing.slug, Slug, forceRefresh, GetImages);
             return RetVal.Result;
         }
 
-		private static async Task<Platform> _GetPlatform(SearchUsing searchUsing, object searchValue, bool forceRefresh)
+        private static async Task<Platform> _GetPlatform(SearchUsing searchUsing, object searchValue, bool forceRefresh, bool GetImages)
         {
             // check database first
             Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -76,13 +78,16 @@ namespace gaseous_server.Classes.Metadata
 
             // set up where clause
             string WhereClause = "";
+            string searchField = "";
             switch (searchUsing)
             {
                 case SearchUsing.id:
                     WhereClause = "where id = " + searchValue;
+                    searchField = "id";
                     break;
                 case SearchUsing.slug:
-                    WhereClause = "where slug = " + searchValue;
+                    WhereClause = "where slug = \"" + searchValue + "\"";
+                    searchField = "slug";
                     break;
                 default:
                     throw new Exception("Invalid search type");
@@ -94,7 +99,7 @@ namespace gaseous_server.Classes.Metadata
                 case Storage.CacheStatus.NotPresent:
                     returnValue = await GetObjectFromServer(WhereClause);
                     Storage.NewCacheValue(returnValue);
-                    UpdateSubClasses(returnValue);
+                    UpdateSubClasses(returnValue, GetImages);
                     AddPlatformMapping(returnValue);
                     return returnValue;
                 case Storage.CacheStatus.Expired:
@@ -102,23 +107,23 @@ namespace gaseous_server.Classes.Metadata
                     {
                         returnValue = await GetObjectFromServer(WhereClause);
                         Storage.NewCacheValue(returnValue, true);
-                        UpdateSubClasses(returnValue);
+                        UpdateSubClasses(returnValue, GetImages);
                         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);
+                        return Storage.GetCacheValue<Platform>(returnValue, searchField, searchValue);
                     }
                 case Storage.CacheStatus.Current:
-                    return Storage.GetCacheValue<Platform>(returnValue, "id", (long)searchValue);
+                    return Storage.GetCacheValue<Platform>(returnValue, searchField, searchValue);
                 default:
                     throw new Exception("How did you get here?");
             }
         }
 
-        private static void UpdateSubClasses(Platform platform)
+        private static void UpdateSubClasses(Platform platform, bool GetImages)
         {
             if (platform.Versions != null)
             {
@@ -128,10 +133,20 @@ namespace gaseous_server.Classes.Metadata
                 }
             }
 
+            if (GetImages == true)
+            {
                 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);
+                    }
+                }
+            }
         }
 
         private static void AddPlatformMapping(Platform platform)
@@ -149,7 +164,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,
@@ -168,11 +184,26 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<Platform> GetObjectFromServer(string WhereClause)
         {
             // get platform metadata
-            var results = await igdb.QueryAsync<Platform>(IGDBClient.Endpoints.Platforms, query: fieldList + " " + WhereClause + ";");
+            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

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static PlayerPerspective? GetGame_PlayerPerspectives(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -105,7 +99,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<PlayerPerspective> GetObjectFromServer(string WhereClause)
         {
             // get Game_PlayerPerspectives metadata
-            var results = await igdb.QueryAsync<PlayerPerspective>(IGDBClient.Endpoints.PlayerPerspectives, query: fieldList + " " + WhereClause + ";");
+            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

@@ -0,0 +1,108 @@
+using System;
+using IGDB;
+using IGDB.Models;
+
+
+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 ReleaseDates()
+        {
+        }
+
+        public static ReleaseDate? GetReleaseDates(long? Id)
+        {
+            if ((Id == 0) || (Id == null))
+            {
+                return null;
+            }
+            else
+            {
+                Task<ReleaseDate> RetVal = _GetReleaseDates(SearchUsing.id, Id);
+                return RetVal.Result;
+            }
+        }
+
+        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

@@ -13,13 +13,7 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
+        public static Screenshot? GetScreenshot(long? Id, string ImagePath, bool GetImages)
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static Screenshot? GetScreenshot(long? Id, string LogoPath)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -27,18 +21,18 @@ namespace gaseous_server.Classes.Metadata
             }
             else
             {
-                Task<Screenshot> RetVal = _GetScreenshot(SearchUsing.id, Id, LogoPath);
+                Task<Screenshot> RetVal = _GetScreenshot(SearchUsing.id, Id, ImagePath, GetImages);
                 return RetVal.Result;
             }
         }
 
-        public static Screenshot GetScreenshot(string Slug, string LogoPath)
+        public static Screenshot GetScreenshot(string Slug, string ImagePath, bool GetImages)
         {
-            Task<Screenshot> RetVal = _GetScreenshot(SearchUsing.slug, Slug, LogoPath);
+            Task<Screenshot> RetVal = _GetScreenshot(SearchUsing.slug, Slug, ImagePath, GetImages);
             return RetVal.Result;
         }
 
-        private static async Task<Screenshot> _GetScreenshot(SearchUsing searchUsing, object searchValue, string LogoPath)
+        private static async Task<Screenshot> _GetScreenshot(SearchUsing searchUsing, object searchValue, string ImagePath, bool GetImages = true)
         {
             // check database first
             Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
@@ -67,21 +61,27 @@ namespace gaseous_server.Classes.Metadata
 
             Screenshot returnValue = new Screenshot();
             bool forceImageDownload = false;
-            LogoPath = Path.Combine(LogoPath, "Screenshots");
+            ImagePath = Path.Combine(ImagePath, "Screenshots");
             switch (cacheStatus)
             {
                 case Storage.CacheStatus.NotPresent:
-                    returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                    returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                     Storage.NewCacheValue(returnValue);
                     forceImageDownload = true;
                     break;
                 case Storage.CacheStatus.Expired:
                     try
                     {
-                        returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                         Storage.NewCacheValue(returnValue, true);
+
+                        // check if old value is different from the new value - only download if it's different
+                        Screenshot oldImage = Storage.GetCacheValue<Screenshot>(returnValue, "id", (long)searchValue);
+                        if (oldImage.ImageId != returnValue.ImageId)
+                        {
                             forceImageDownload = true;
                         }
+                    }
                     catch (Exception ex)
                     {
                         Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
@@ -95,11 +95,17 @@ namespace gaseous_server.Classes.Metadata
                     throw new Exception("How did you get here?");
             }
 
-            if ((!File.Exists(Path.Combine(LogoPath, "Screenshot.jpg"))) || forceImageDownload == true)
+            // 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)
             {
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_thumb, returnValue.ImageId);
+                if ((!File.Exists(localFile)) || forceImageDownload == true)
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med, returnValue.ImageId);
+                {
-                GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_original, returnValue.ImageId);
+                    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;
@@ -111,64 +117,15 @@ namespace gaseous_server.Classes.Metadata
             slug
         }
 
-        private static async Task<Screenshot> GetObjectFromServer(string WhereClause, string LogoPath)
+        private static async Task<Screenshot> GetObjectFromServer(string WhereClause, string ImagePath)
         {
             // get Screenshot metadata
-            var results = await igdb.QueryAsync<Screenshot>(IGDBClient.Endpoints.Screenshots, query: fieldList + " " + WhereClause + ";");
+            Communications comms = new Communications();
+            var results = await comms.APIComm<Screenshot>(IGDBClient.Endpoints.Screenshots, fieldList, WhereClause);
             var result = results.First();
 
-            //GetImageFromServer(result.Url, LogoPath, LogoSize.t_thumb, result.ImageId);
-            //GetImageFromServer(result.Url, LogoPath, LogoSize.t_logo_med, result.ImageId);
-            GetImageFromServer(result.Url, LogoPath, LogoSize.t_original, result.ImageId);
-
             return result;
         }
-
-        private static void GetImageFromServer(string Url, string LogoPath, LogoSize logoSize, string ImageId)
-        {
-            using (var client = new HttpClient())
-            {
-                string fileName = "Artwork.jpg";
-                string extension = "jpg";
-                switch (logoSize)
-                {
-                    case LogoSize.t_thumb:
-                        fileName = "_Thumb";
-                        extension = "jpg";
-                        break;
-                    case LogoSize.t_logo_med:
-                        fileName = "_Medium";
-                        extension = "png";
-                        break;
-                    case LogoSize.t_original:
-                        fileName = "";
-                        extension = "png";
-                        break;
-                    default:
-                        fileName = "Artwork";
-                        extension = "jpg";
-                        break;
-                }
-                fileName = ImageId + fileName;
-                string imageUrl = Url.Replace(LogoSize.t_thumb.ToString(), logoSize.ToString()).Replace("jpg", extension);
-
-                using (var s = client.GetStreamAsync("https:" + imageUrl))
-                {
-                    if (!Directory.Exists(LogoPath)) { Directory.CreateDirectory(LogoPath); }
-                    using (var fs = new FileStream(Path.Combine(LogoPath, fileName + "." + extension), FileMode.OpenOrCreate))
-                    {
-                        s.Result.CopyTo(fs);
-                    }
-                }
-            }
-        }
-
-        private enum LogoSize
-        {
-            t_thumb,
-            t_logo_med,
-            t_original
-        }
     }
 }
 

gaseous-server/Classes/Metadata/Storage.cs

@@ -16,33 +16,15 @@ namespace gaseous_server.Classes.Metadata
             Expired
         }
 
-        private static Dictionary<string, MemoryCacheObject> ObjectCache = new Dictionary<string, MemoryCacheObject>();
-
         public static CacheStatus GetCacheStatus(string Endpoint, string Slug)
-		{
-            CacheClean();
-            if (ObjectCache.ContainsKey(Endpoint + Slug))
-            {
-                return CacheStatus.Current;
-            }
-            else
         {
             return _GetCacheStatus(Endpoint, "slug", Slug);
         }
-		}
 
         public static CacheStatus GetCacheStatus(string Endpoint, long Id)
         {
-            CacheClean();
-            if (ObjectCache.ContainsKey(Endpoint + Id))
-            {
-                return CacheStatus.Current;
-            }
-            else
-			{
             return _GetCacheStatus(Endpoint, "id", Id);
         }
-        }
 
         public static CacheStatus GetCacheStatus(DataRow Row)
         {
@@ -185,21 +167,6 @@ namespace gaseous_server.Classes.Metadata
         {
             string Endpoint = EndpointType.GetType().Name;
 
-            if (ObjectCache.ContainsKey(Endpoint + SearchValue))
-            {
-                MemoryCacheObject cacheObject = ObjectCache[Endpoint + SearchValue];
-                if (cacheObject.ExpiryTime < DateTime.UtcNow)
-                {
-                    // object has expired, remove it
-                    ObjectCache.Remove(Endpoint + SearchValue);
-                }
-                else
-                {
-                    // object is valid, return it
-                    return (T)cacheObject.Object;
-                }
-            }
-
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
             string sql = "SELECT * FROM " + Endpoint + " WHERE " + SearchField + " = @" + SearchField;
@@ -208,7 +175,7 @@ namespace gaseous_server.Classes.Metadata
             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
@@ -218,9 +185,7 @@ namespace gaseous_server.Classes.Metadata
             {
                 DataRow dataRow = dt.Rows[0];
                 object returnObject = BuildCacheObject<T>(EndpointType, dataRow);
-                ObjectCache.Add(Endpoint + SearchValue, new MemoryCacheObject{
+
-                    Object = returnObject
-                });
                 return (T)returnObject;
             }
         }
@@ -404,6 +369,15 @@ namespace gaseous_server.Classes.Metadata
                                 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]);
                                     break;
@@ -454,27 +428,28 @@ namespace gaseous_server.Classes.Metadata
             }
         }
 
-        private static void CacheClean()
+        public static void CreateRelationsTables<T>()
         {
-            try
+            string PrimaryTable = typeof(T).Name;
+            foreach (PropertyInfo property in typeof(T).GetProperties())
             {
-                if (ObjectCache == null)
+                string SecondaryTable = property.Name;
+
+                if (property.PropertyType.Name == "IdentitiesOrValues`1")
                 {
-                    ObjectCache = new Dictionary<string, MemoryCacheObject>();
+
-                }
+                    string TableName = "Relation_" + PrimaryTable + "_" + SecondaryTable;
-                Dictionary<string, MemoryCacheObject> workCache = ObjectCache;
+                    Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-                foreach (KeyValuePair<string, MemoryCacheObject> objectCache in workCache)
+                    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)
                     {
-                    if (objectCache.Value.ExpiryTime < DateTime.UtcNow)
+                        // 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);";
-                        ObjectCache.Remove(objectCache.Key);
+                        db.ExecuteCMD(sql);
                     }
                 }
             }
-            catch
-            {
-                ObjectCache = new Dictionary<string, MemoryCacheObject>();
-            }
         }
 
         private class MemoryCacheObject

gaseous-server/Classes/Metadata/Themes.cs

@@ -13,12 +13,6 @@ namespace gaseous_server.Classes.Metadata
         {
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
         public static Theme? GetGame_Themes(long? Id)
         {
             if ((Id == 0) || (Id == null))
@@ -105,7 +99,8 @@ namespace gaseous_server.Classes.Metadata
         private static async Task<Theme> GetObjectFromServer(string WhereClause)
         {
             // get Game_Themes metadata
-            var results = await igdb.QueryAsync<Theme>(IGDBClient.Endpoints.Themes, query: fieldList + " " + WhereClause + ";");
+            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

@@ -4,47 +4,71 @@ using gaseous_server.Models;
 
 namespace gaseous_server.Classes
 {
-	public class MetadataManagement
+	public class MetadataManagement : QueueItemStatus
 	{
-		public static void RefreshMetadata(bool forceRefresh = false)
+		public void RefreshMetadata(bool forceRefresh = false)
 		{
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "";
 			DataTable dt = new DataTable();
 			
+			// disabling forceRefresh
+			forceRefresh = false;
+
 			// update platforms
 			sql = "SELECT Id, `Name` FROM Platform;";
 			dt = db.ExecuteCMD(sql);
 
+			int StatusCounter = 1;
 			foreach (DataRow dr in dt.Rows)
 			{
+				SetStatus(StatusCounter, dt.Rows.Count, "Refreshing metadata for platform " + dr["name"]);
+
 				try
 				{
-					Logging.Log(Logging.LogType.Information, "Metadata Refresh", "Refreshing metadata for platform " + dr["name"] + " (" + dr["id"] + ")");
+					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);
 				}
 				catch (Exception ex)
 				{
 					Logging.Log(Logging.LogType.Critical, "Metadata Refresh", "An error occurred while refreshing metadata for " + dr["name"], ex);
 				}
+
+				StatusCounter += 1;
 			}
+			ClearStatus();
 
 			// update games
+			if (forceRefresh == true)
+			{
+				// when forced, only update games with ROMs for
+				sql = "SELECT Id, `Name` FROM view_GamesWithRoms;";
+			}
+			else
+			{
+				// when run normally, update all games (since this will honour cache timeouts)
 				sql = "SELECT Id, `Name` FROM Game;";
+			}
 			dt = db.ExecuteCMD(sql);
 
+			StatusCounter = 1;
 			foreach (DataRow dr in dt.Rows)
 			{
+				SetStatus(StatusCounter, dt.Rows.Count, "Refreshing metadata for game " + dr["name"]);
+
 				try
 				{
-					Logging.Log(Logging.LogType.Information, "Metadata Refresh", "Refreshing metadata for game " + dr["name"] + " (" + dr["id"] + ")");
+					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, true, forceRefresh);
+					Metadata.Games.GetGame((long)dr["id"], true, false, true);
 				}
 				catch (Exception ex)
 				{
 					Logging.Log(Logging.LogType.Critical, "Metadata Refresh", "An error occurred while refreshing metadata for " + dr["name"], ex);
 				}
+
+				StatusCounter += 1;
 			}
+			ClearStatus();
         }
 	}
 }

gaseous-server/Classes/QueueItemStatus.cs

@@ -0,0 +1,41 @@
+namespace gaseous_server.Classes
+{
+    public class QueueItemStatus
+    {
+        internal ProcessQueue.QueueItem? CallingQueueItem = null;
+
+        private int _CurrentItemNumber = 0;
+        private int _MaxItemsNumber = 0;
+        private string _StatusText = "";
+
+        public int CurrentItemNumber => _CurrentItemNumber;
+        public int MaxItemsNumber => _MaxItemsNumber;
+        public string StatusText => _StatusText;
+
+        public void SetStatus(int CurrentItemNumber, int MaxItemsNumber, string StatusText)
+        {
+            this._CurrentItemNumber = CurrentItemNumber;
+            this._MaxItemsNumber = MaxItemsNumber;
+            this._StatusText = StatusText;
+
+            if (CallingQueueItem != null)
+            {
+                CallingQueueItem.CurrentState = _CurrentItemNumber + " of " + _MaxItemsNumber + ": " + _StatusText;
+                CallingQueueItem.CurrentStateProgress = _CurrentItemNumber + " of " + _MaxItemsNumber;
+            }
+        }
+
+        public void ClearStatus()
+        {
+            this._CurrentItemNumber = 0;
+            this._MaxItemsNumber = 0;
+            this._StatusText = "";
+
+            if (CallingQueueItem != null)
+            {
+                CallingQueueItem.CurrentState = "";
+                CallingQueueItem.CurrentStateProgress = "";
+            }
+        }
+    }
+}

gaseous-server/Classes/RomMediaGroup.cs

@@ -5,6 +5,9 @@ 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;
 
 namespace gaseous_server.Classes
 {
@@ -55,12 +58,15 @@ namespace gaseous_server.Classes
             return GetMediaGroup(mgId);
         }
 
-        public static GameRomMediaGroupItem GetMediaGroup(long Id)
+        public static GameRomMediaGroupItem GetMediaGroup(long Id, string userid = "")
         {
             Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT * FROM RomMediaGroup WHERE Id=@id;";
+            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.Id=@id;";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
-            dbDict.Add("id", Id);
+            {
+                { "id", Id },
+                { "userid", userid }
+            };
 
             DataTable dataTable = db.ExecuteCMD(sql, dbDict);
 
@@ -75,12 +81,43 @@ namespace gaseous_server.Classes
             }
         }
 
-        public static List<GameRomMediaGroupItem> GetMediaGroupsFromGameId(long GameId)
+        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 * FROM RomMediaGroup WHERE 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>();
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
-            dbDict.Add("gameid", GameId);
+            {
+                { "gameid", GameId },
+                { "userid", userid },
+                { "platformid", PlatformId }
+            };
 
             DataTable dataTable = db.ExecuteCMD(sql, dbDict);
 
@@ -91,7 +128,7 @@ namespace gaseous_server.Classes
                 mediaGroupItems.Add(BuildMediaGroupFromRow(row));
             }
 
-            mediaGroupItems.Sort((x, y) => x.PlatformName.CompareTo(y.PlatformName));
+            mediaGroupItems.Sort((x, y) => x.Platform.CompareTo(y.Platform));
 
             return mediaGroupItems;
         }
@@ -156,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;";
+            string sql = "DELETE FROM RomMediaGroup WHERE Id=@id; DELETE FROM GameState 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);
@@ -170,12 +207,43 @@ namespace gaseous_server.Classes
 
         internal static GameRomMediaGroupItem BuildMediaGroupFromRow(DataRow row)
         {
-            GameRomMediaGroupItem mediaGroupItem = new GameRomMediaGroupItem();
+            bool hasSaveStates = false;
-            mediaGroupItem.Id = (long)row["Id"];
+            if (row.Table.Columns.Contains("GameStateRomId"))
-            mediaGroupItem.Status = (GameRomMediaGroupItem.GroupBuildStatus)row["Status"];
+            {
-            mediaGroupItem.PlatformId = (long)row["PlatformId"];
+                if (row["GameStateRomId"] != DBNull.Value)
-            mediaGroupItem.GameId = (long)row["GameId"];
+                {
-            mediaGroupItem.RomIds = new List<long>();
+                    hasSaveStates = true;
+                }
+            }
+
+            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);
@@ -186,6 +254,14 @@ namespace gaseous_server.Classes
             foreach (DataRow dataRow in data.Rows)
             {
                 mediaGroupItem.RomIds.Add((long)dataRow["RomId"]);
+                try
+                {
+                    mediaGroupItem.Roms.Add(Roms.GetRom((long)dataRow["RomId"]));
+                }
+                catch (Exception ex)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Rom Group", "Unable to load ROM data", ex);
+                }
             }
 
             return mediaGroupItem;
@@ -222,6 +298,7 @@ namespace gaseous_server.Classes
             {
                 Game GameObject = Games.GetGame(mediaGroupItem.GameId, false, false, false);
                 Platform PlatformObject = Platforms.GetPlatform(mediaGroupItem.PlatformId, false);
+                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);
 
@@ -256,10 +333,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);
                         }
@@ -360,7 +551,8 @@ namespace gaseous_server.Classes
             public long Id { get; set; }
             public long GameId { get; set; }
             public long PlatformId { get; set; }
-            public string PlatformName {
+            public string Platform
+            {
                 get
                 {
                     try
@@ -374,8 +566,13 @@ namespace gaseous_server.Classes
                 }
             }
             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)
@@ -399,7 +596,8 @@ namespace gaseous_server.Classes
                     _Status = value;
                 }
             }
-			public long? Size {
+            public long? Size
+            {
                 get
                 {
                     if (Status == GroupBuildStatus.Completed)

gaseous-server/Classes/Roms.cs

@@ -3,6 +3,10 @@ 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
 {
@@ -14,32 +18,90 @@ namespace gaseous_server.Classes
 			{ }
 		}
 
-		public static GameRomObject GetRoms(long GameId, long PlatformId = -1)
+		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();
 
 			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 			string sql = "";
+			string sqlCount = "";
+			string sqlPlatform = "";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
 			dbDict.Add("id", GameId);
+			dbDict.Add("userid", userid);
+
+			string NameSearchWhere = "";
+			if (NameSearch.Length > 0)
+			{
+				NameSearchWhere = " AND Games_Roms.`Name` LIKE @namesearch";
+				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.GameId
+					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.GameId
+					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)
+			{
+				// data query
+				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename, GameState.RomId AS SavedStateRomId" + UserFields + " FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) " + UserJoin + " WHERE Games_Roms.GameId = @id" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+
+				// count query
+				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id" + NameSearchWhere + ";";
+			}
+			else
+			{
+				// data query
+				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename, GameState.RomId AS SavedStateRomId" + UserFields + " FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) " + UserJoin + " WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+
+				// count query
+				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + ";";
 
-			if (PlatformId == -1) {
-				sql = "SELECT * FROM Games_Roms WHERE GameId = @id ORDER BY `Name`";
-			} else {
-				sql = "SELECT * FROM Games_Roms WHERE GameId = @id AND PlatformId = @platformid ORDER BY `Name`";
 				dbDict.Add("platformid", PlatformId);
 			}
-            DataTable romDT = db.ExecuteCMD(sql, dbDict);
+			DataTable romDT = db.ExecuteCMD(sql, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromMinutes(1).Ticks));
+			Dictionary<string, object> rowCount = db.ExecuteCMDDict(sqlCount, dbDict, new Database.DatabaseMemoryCacheOptions(true, (int)TimeSpan.FromMinutes(1).Ticks))[0];
 
 			if (romDT.Rows.Count > 0)
 			{
-				foreach (DataRow romDR in romDT.Rows)
+				// set count of roms
-				{
+				GameRoms.Count = int.Parse((string)rowCount["RomCount"]);
-					GameRoms.GameRomItems.Add(BuildRom(romDR));
-				}
 
-				// get rom media groups
+				int pageOffset = pageSize * (pageNumber - 1);
-				GameRoms.MediaGroups = Classes.RomMediaGroup.GetMediaGroupsFromGameId(GameId);
+				for (int i = 0; i < romDT.Rows.Count; i++)
+				{
+					if ((i >= pageOffset && i < pageOffset + pageSize) || pageSize == 0)
+					{
+						GameRomItem gameRomItem = BuildRom(romDT.Rows[i]);
+						GameRoms.GameRomItems.Add(gameRomItem);
+					}
+				}
 
 				return GameRoms;
 			}
@@ -52,7 +114,7 @@ namespace gaseous_server.Classes
 		public static GameRomItem GetRom(long RomId)
 		{
 			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql = "SELECT * FROM Games_Roms WHERE Id = @id";
+			string sql = "SELECT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id WHERE Games_Roms.Id = @id";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
 			dbDict.Add("id", RomId);
 			DataTable romDT = db.ExecuteCMD(sql, dbDict);
@@ -69,6 +131,26 @@ namespace gaseous_server.Classes
 			}
 		}
 
+		public static GameRomItem GetRom(string MD5)
+		{
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT Games_Roms.*, Platform.`Name` AS platformname, Game.`Name` AS gamename FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN Game ON Games_Roms.GameId = Game.Id WHERE 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
@@ -87,6 +169,53 @@ 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.AddHeader("X-API-Key", Config.MetadataConfiguration.HasheousAPIKey);
+							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;
 		}
 
@@ -101,7 +230,7 @@ namespace gaseous_server.Classes
 				}
 
 				Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-				string sql = "DELETE FROM Games_Roms WHERE Id = @id";
+				string sql = "DELETE FROM Games_Roms WHERE Id = @id; DELETE FROM GameState WHERE RomId = @id; 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);
@@ -110,38 +239,71 @@ namespace gaseous_server.Classes
 
 		private static GameRomItem BuildRom(DataRow romDR)
 		{
+			bool hasSaveStates = false;
+			if (romDR.Table.Columns.Contains("SavedStateRomId"))
+			{
+				if (romDR["SavedStateRomId"] != DBNull.Value)
+				{
+					hasSaveStates = true;
+				}
+			}
+
+			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 = Classes.Metadata.Platforms.GetPlatform((long)romDR["platformid"]),
+				Platform = (string)romDR["platformname"],
 				GameId = (long)romDR["gameid"],
+				Game = (string)romDR["gamename"],
 				Name = (string)romDR["name"],
 				Size = (long)romDR["size"],
-                CRC = ((string)romDR["crc"]).ToLower(),
+				Crc = ((string)romDR["crc"]).ToLower(),
-                MD5 = ((string)romDR["md5"]).ToLower(),
+				Md5 = ((string)romDR["md5"]).ToLower(),
-                SHA1 = ((string)romDR["sha1"]).ToLower(),
+				Sha1 = ((string)romDR["sha1"]).ToLower(),
 				DevelopmentStatus = (string)romDR["developmentstatus"],
-                Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<List<KeyValuePair<string, object>>>((string)Common.ReturnValueIfNull(romDR["attributes"], "[ ]")),
+				Attributes = romAttributes,
-                RomType = (int)romDR["romtype"],
+				RomType = (HasheousClient.Models.SignatureModel.RomItem.RomTypes)(int)romDR["romtype"],
 				RomTypeMedia = (string)romDR["romtypemedia"],
 				MediaLabel = (string)romDR["medialabel"],
 				Path = (string)romDR["path"],
-				Source = (gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType)(Int32)romDR["metadatasource"],
+				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
+			romItem.RomUserLastUsed = false;
-			foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
+			if (romDR.Table.Columns.Contains("MostRecentRomId"))
 			{
-				if (platformMapping.IGDBId == romItem.PlatformId)
+				if (romDR["MostRecentRomId"] != DBNull.Value)
 				{
-					if (platformMapping.WebEmulator != null)
+					romItem.RomUserLastUsed = true;
-					{
-						romItem.Emulator = platformMapping.WebEmulator;
 				}
 			}
+
+			romItem.RomUserFavourite = false;
+			if (romDR.Table.Columns.Contains("FavouriteRomId"))
+			{
+				if (romDR["FavouriteRomId"] != DBNull.Value)
+				{
+					romItem.RomUserFavourite = true;
+				}
 			}
 
 			return romItem;
@@ -149,133 +311,22 @@ namespace gaseous_server.Classes
 
 		public class GameRomObject
 		{
-			public List<GameRomMediaGroupItem> MediaGroups { get; set; } = new List<GameRomMediaGroupItem>();
 			public List<GameRomItem> GameRomItems { get; set; } = new List<GameRomItem>();
+			public int Count { get; set; }
 		}
 
-		public class GameRomItem
+		public class GameRomItem : HasheousClient.Models.SignatureModel.RomItem
 		{
-			public long Id { get; set; }
 			public long PlatformId { get; set; }
-			public IGDB.Models.Platform Platform { get; set; }
+			public string Platform { get; set; }
-			//public Dictionary<string, object>? Emulator { get; set; }
-            public Models.PlatformMapping.PlatformMapItem.WebEmulatorItem? Emulator { get; set; }
 			public long GameId { get; set; }
-			public string? Name { get; set; }
+			public string Game { get; set; }
-			public long Size { get; set; }
-			public string? CRC { get; set; }
-			public string? MD5 { get; set; }
-			public string? SHA1 { get; set; }
-			public string? DevelopmentStatus { get; set; }
-			public string[]? Flags { get; set; }
-			public List<KeyValuePair<string, object>>? Attributes { get; set;}
-			public int RomType { get; set; }
-			public string? RomTypeMedia { get; set; }
-			public MediaType? MediaDetail {
-				get
-				{
-					if (RomTypeMedia != null)
-					{
-						return new MediaType(Source, RomTypeMedia);
-					}
-					else
-					{
-						return null;
-					}
-				}
-			}
-			public string? MediaLabel { get; set; }
 			public string? Path { get; set; }
-            public RomSignatureObject.Game.Rom.SignatureSourceType Source { 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; }
-		public class MediaType
-		{
-			public MediaType(RomSignatureObject.Game.Rom.SignatureSourceType Source, string MediaTypeString)
-			{
-				switch (Source)
-				{
-					case RomSignatureObject.Game.Rom.SignatureSourceType.TOSEC:
-						string[] typeString = MediaTypeString.Split(" ");
-
-						string inType = "";
-						foreach (string typeStringVal in typeString)
-						{
-							if (inType == "")
-							{
-								switch (typeStringVal.ToLower())
-								{
-									case "disk":
-										Media = RomSignatureObject.Game.Rom.RomTypes.Disk;
-
-										inType = typeStringVal;
-										break;
-									case "disc":
-										Media = RomSignatureObject.Game.Rom.RomTypes.Disc;
-
-										inType = typeStringVal;
-										break;
-									case "file":
-										Media = RomSignatureObject.Game.Rom.RomTypes.File;
-
-										inType = typeStringVal;
-										break;
-									case "part":
-										Media = RomSignatureObject.Game.Rom.RomTypes.Part;
-
-										inType = typeStringVal;
-										break;
-									case "tape":
-										Media = RomSignatureObject.Game.Rom.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 RomSignatureObject.Game.Rom.RomTypes? Media { get; set; }
-
-			public int? Number { get; set; }
-
-			public int? Count { get; set; }
-
-			public string? Side { get; set; }
 		}
 	}
 }

gaseous-server/Classes/SignatureIngestors/XML.cs

@@ -6,23 +6,51 @@ using System.Data;
 
 namespace gaseous_server.SignatureIngestors.XML
 {
-    public class XMLIngestor
+    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;
@@ -31,6 +59,30 @@ namespace gaseous_server.SignatureIngestors.XML
             {
                 string XMLFile = PathContents[i];
 
+                SetStatus(i + 1, PathContents.Length, "Processing signature file: " + XMLFile);
+
+                Logging.Log(Logging.LogType.Information, "Signature Ingest", "(" + (i + 1) + " / " + PathContents.Length + ") Processing " + XMLType.ToString() + " DAT file: " + XMLFile);
+
+                string? DBFile = null;
+                if (XMLDBSearchPath != null)
+                {
+                    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;
+                                }
+                            }
+                            break;
+                    }
+                }
+
                 // check xml file md5
                 Common.hashObject hashObject = new Common.hashObject(XMLFile);
                 sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
@@ -42,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 = {
@@ -58,21 +108,27 @@ namespace gaseous_server.SignatureIngestors.XML
                         bool processGames = false;
                         if (Object.SourceMd5 != null)
                         {
-                            sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
+                            int sourceId = 0;
-                            dbDict = new Dictionary<string, object>();
+
-                            string sourceUriStr = "";
+                            sql = "SELECT * FROM Signatures_Sources WHERE `SourceMD5`=@sourcemd5";
-                            if (Object.Url != null)
+                            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);
@@ -81,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;
                             }
@@ -113,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]);
@@ -143,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]);
                                         }
@@ -161,16 +286,16 @@ namespace gaseous_server.SignatureIngestors.XML
                                     dbDict.Add("publisherid", gamePublisher);
 
                                     // store game
-                                    int gameId = 0;
+                                    long 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";
+                                    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`, `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); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
                                         sigDB = db.ExecuteCMD(sql, dbDict);
 
                                         gameId = Convert.ToInt32(sigDB.Rows[0][0]);
@@ -180,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;
+                                            long romId = 0;
-                                            sql = "SELECT * FROM Signatures_Roms WHERE GameId=@gameid AND MD5=@md5";
+                                            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, ""));
@@ -204,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, ""));
@@ -221,32 +390,55 @@ 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)));
                     }
                 }
             }
+            ClearStatus();
+        }
     }
 }

gaseous-server/Classes/SignatureManagement.cs

@@ -0,0 +1,157 @@
+using System.Data;
+using gaseous_server.Models;
+using gaseous_signature_parser.models.RomSignatureObject;
+using static gaseous_server.Classes.Common;
+
+namespace gaseous_server.Classes
+{
+    public class SignatureManagement
+    {
+        public List<gaseous_server.Models.Signatures_Games> GetSignature(string md5 = "", string sha1 = "")
+        {
+            if (md5.Length > 0)
+            {
+                return _GetSignature("Signatures_Roms.md5 = @searchstring", md5);
+            }
+            else
+            {
+                return _GetSignature("Signatures_Roms.sha1 = @searchstring", sha1);
+            }
+        }
+
+        public List<gaseous_server.Models.Signatures_Games> GetByTosecName(string TosecName = "")
+        {
+            if (TosecName.Length > 0)
+            {
+                return _GetSignature("Signatures_Roms.name = @searchstring", TosecName);
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        private List<gaseous_server.Models.Signatures_Games> _GetSignature(string sqlWhere, string searchString)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT     view_Signatures_Games.*,    Signatures_Roms.Id AS romid,    Signatures_Roms.Name AS romname,    Signatures_Roms.Size,    Signatures_Roms.CRC,    Signatures_Roms.MD5,    Signatures_Roms.SHA1,    Signatures_Roms.DevelopmentStatus,    Signatures_Roms.Attributes,    Signatures_Roms.RomType,    Signatures_Roms.RomTypeMedia,    Signatures_Roms.MediaLabel,    Signatures_Roms.MetadataSource FROM    Signatures_Roms        INNER JOIN    view_Signatures_Games ON Signatures_Roms.GameId = view_Signatures_Games.Id WHERE " + sqlWhere;
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("searchString", searchString);
+
+            DataTable sigDb = db.ExecuteCMD(sql, dbDict);
+
+            List<gaseous_server.Models.Signatures_Games> GamesList = new List<gaseous_server.Models.Signatures_Games>();
+
+            foreach (DataRow sigDbRow in sigDb.Rows)
+            {
+                gaseous_server.Models.Signatures_Games gameItem = new gaseous_server.Models.Signatures_Games
+                {
+                    Game = new gaseous_server.Models.Signatures_Games.GameItem
+                    {
+                        Id = (long)(int)sigDbRow["Id"],
+                        Name = (string)sigDbRow["Name"],
+                        Description = (string)sigDbRow["Description"],
+                        Year = (string)sigDbRow["Year"],
+                        Publisher = (string)sigDbRow["Publisher"],
+                        Demo = (gaseous_server.Models.Signatures_Games.GameItem.DemoTypes)(int)sigDbRow["Demo"],
+                        System = (string)sigDbRow["Platform"],
+                        SystemVariant = (string)sigDbRow["SystemVariant"],
+                        Video = (string)sigDbRow["Video"],
+                        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 = (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<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"],
+                        SignatureSource = (gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType)(Int32)sigDbRow["MetadataSource"]
+                    }
+                };
+                GamesList.Add(gameItem);
+            }
+            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

@@ -0,0 +1,117 @@
+using System.Data;
+using gaseous_server.Models;
+
+namespace gaseous_server.Classes
+{
+    public class Statistics
+    {
+        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 = 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, 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 },
+                    { "platformid", PlatformId },
+                    { "ismediagroup", IsMediaGroup },
+                    { "romid", RomId }
+                };
+
+                db.ExecuteNonQuery(sql, dbDict);
+
+                return new StatisticsModel
+                {
+                    GameId = GameId,
+                    SessionId = SessionId,
+                    SessionStart = (DateTime)dbDict["sessiontime"],
+                    SessionLength = (int)dbDict["sessionlength"]
+                };
+            }
+            else
+            {
+                // update existing session
+                sql = "UPDATE UserTimeTracking SET SessionLength = SessionLength + @sessionlength WHERE GameId = @gameid AND UserId = @userid AND SessionId = @sessionid;";
+                dbDict = new Dictionary<string, object>{
+                    { "gameid", GameId },
+                    { "userid", UserId },
+                    { "sessionid", SessionId },
+                    { "sessionlength", 1 }
+                };
+
+                db.ExecuteNonQuery(sql, dbDict);
+
+                sql = "SELECT * FROM UserTimeTracking WHERE GameId = @gameid AND UserId = @userid AND SessionId = @sessionid;";
+                DataTable data = db.ExecuteCMD(sql, dbDict);
+
+                return new StatisticsModel
+                {
+                    GameId = (long)data.Rows[0]["GameId"],
+                    SessionId = Guid.Parse(data.Rows[0]["SessionId"].ToString()),
+                    SessionStart = (DateTime)data.Rows[0]["SessionTime"],
+                    SessionLength = (int)data.Rows[0]["SessionLength"]
+                };
+            }
+        }
+
+        public StatisticsModel? GetSession(long GameId, string UserId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT SUM(SessionLength) AS TotalLength FROM UserTimeTracking WHERE GameId = @gameid AND UserId = @userid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "gameid", GameId },
+                { "userid", UserId }
+            };
+
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            if (data.Rows.Count == 0)
+            {
+                return null;
+            }
+            else
+            {
+                if (data.Rows[0]["TotalLength"] == DBNull.Value)
+                {
+                    return null;
+                }
+                else
+                {
+                    int TotalTime = int.Parse(data.Rows[0]["TotalLength"].ToString());
+
+                    sql = "SELECT * FROM UserTimeTracking WHERE GameId = @gameid AND UserId = @userid ORDER BY SessionTime DESC LIMIT 1;";
+                    data = db.ExecuteCMD(sql, dbDict);
+
+                    return new StatisticsModel
+                    {
+                        GameId = GameId,
+                        SessionLength = TotalTime,
+                        SessionStart = (DateTime)data.Rows[0]["SessionTime"]
+                    };
+                }
+            }
+        }
+    }
+}

gaseous-server/Classes/UserProfile.cs

@@ -0,0 +1,187 @@
+using System.Data;
+
+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)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT Id, 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()
+                };
+            }
+
+            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,
+                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

@@ -1,3 +1,4 @@
+using System.Data;
 using System.Security.Claims;
 using System.Text;
 using Authentication;
@@ -7,6 +8,8 @@ using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Identity.UI.Services;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Rendering;
+using Asp.Versioning;
+using IGDB;
 
 namespace gaseous_server.Controllers
 {
@@ -95,6 +98,8 @@ namespace gaseous_server.Controllers
             profile.EmailAddress = await _userManager.GetEmailAsync(user);
             profile.Roles = new List<string>(await _userManager.GetRolesAsync(user));
             profile.SecurityProfile = user.SecurityProfile;
+            profile.UserPreferences = user.UserPreferences;
+            profile.ProfileId = user.ProfileId;
             profile.Roles.Sort();
 
             return Ok(profile);
@@ -115,6 +120,7 @@ namespace gaseous_server.Controllers
                 profile.EmailAddress = await _userManager.GetEmailAsync(user);
                 profile.Roles = new List<string>(await _userManager.GetRolesAsync(user));
                 profile.SecurityProfile = user.SecurityProfile;
+                profile.UserPreferences = user.UserPreferences;
                 profile.Roles.Sort();
 
                 string profileString = "var userProfile = " + Newtonsoft.Json.JsonConvert.SerializeObject(profile, Newtonsoft.Json.Formatting.Indented) + ";";
@@ -182,6 +188,7 @@ namespace gaseous_server.Controllers
                 user.LockoutEnabled = rawUser.LockoutEnabled;
                 user.LockoutEnd = rawUser.LockoutEnd;
                 user.SecurityProfile = rawUser.SecurityProfile;
+                user.ProfileId = rawUser.ProfileId;
 
                 // get roles
                 ApplicationUser? aUser = await _userManager.FindByIdAsync(rawUser.Id);
@@ -213,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)
                 {
@@ -234,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")]
@@ -249,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);
@@ -375,7 +404,7 @@ namespace gaseous_server.Controllers
                     IdentityResult passwordChangeResult = await _userManager.ResetPasswordAsync(user, resetToken, model.NewPassword);
                     if (passwordChangeResult.Succeeded == true)
                     {
-                        return Ok();
+                        return Ok(passwordChangeResult);
                     }
                     else
                     {
@@ -392,5 +421,133 @@ namespace gaseous_server.Controllers
                 return NotFound();
             }
         }
+
+        [HttpPost]
+        [Route("Preferences")]
+        public async Task<IActionResult> SetPreferences(List<UserPreferenceViewModel> model)
+        {
+            ApplicationUser? user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                return Unauthorized();
+            }
+            else
+            {
+                user.UserPreferences = model;
+                await _userManager.UpdateAsync(user);
+
+                return Ok();
+            }
+        }
+
+        [HttpPost]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [RequestSizeLimit(long.MaxValue)]
+        [Consumes("multipart/form-data")]
+        [DisableRequestSizeLimit, RequestFormLimits(MultipartBodyLengthLimit = long.MaxValue, ValueLengthLimit = int.MaxValue)]
+        [Route("Avatar")]
+        public async Task<IActionResult> UploadAvatar(IFormFile file)
+        {
+            ApplicationUser? user = await _userManager.GetUserAsync(User);
+            if (user == null)
+            {
+                return Unauthorized();
+            }
+            else
+            {
+                Guid avatarId = Guid.Empty;
+
+                if (file.Length > 0)
+                {
+                    using (var ms = new MemoryStream())
+                    {
+                        file.CopyTo(ms);
+                        byte[] fileBytes = ms.ToArray();
+                        byte[] targetBytes;
+
+                        using (var image = new ImageMagick.MagickImage(fileBytes))
+                        {
+                            ImageMagick.MagickGeometry size = new ImageMagick.MagickGeometry(256, 256);
+
+                            // This will resize the image to a fixed size without maintaining the aspect ratio.
+                            // Normally an image will be resized to fit inside the specified size.
+                            size.IgnoreAspectRatio = true;
+
+                            image.Resize(size);
+                            var newMs = new MemoryStream();
+                            image.Resize(size);
+                            image.Strip();
+                            image.Write(newMs, ImageMagick.MagickFormat.Jpg);
+
+                            targetBytes = newMs.ToArray();
+                        }
+
+                        Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                        UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
+                        avatarId = userTable.SetAvatar(user, targetBytes);
+                    }
+                }
+
+                return Ok(avatarId);
+            }
+        }
+
+        [HttpGet]
+        [Route("Avatar/{id}.jpg")]
+        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public ActionResult GetAvatar(Guid id)
+        {
+            if (id == Guid.Empty)
+            {
+                return NotFound();
+            }
+            else
+            {
+                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                string sql = "SELECT * FROM UserAvatars WHERE Id = @id";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                    { "id", id }
+                };
+
+                DataTable data = db.ExecuteCMD(sql, dbDict);
+
+                if (data.Rows.Count > 0)
+                {
+                    string filename = id.ToString() + ".jpg";
+                    byte[] filedata = (byte[])data.Rows[0]["Avatar"];
+                    string contentType = "image/jpg";
+
+                    var cd = new System.Net.Mime.ContentDisposition
+                    {
+                        FileName = filename,
+                        Inline = true,
+                    };
+
+                    Response.Headers.Add("Content-Disposition", cd.ToString());
+                    Response.Headers.Add("Cache-Control", "public, max-age=604800");
+
+                    return File(filedata, contentType);
+                }
+                else
+                {
+                    return NotFound();
+                }
+            }
+        }
+
+        [HttpDelete]
+        [Route("Avatar/{id}.jpg")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<ActionResult> DeleteAvatarAsync()
+        {
+            ApplicationUser? user = await _userManager.GetUserAsync(User);
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            UserTable<ApplicationUser> userTable = new UserTable<ApplicationUser>(db);
+            userTable.SetAvatar(user, new byte[0]);
+
+            return Ok();
+        }
     }
 }

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

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {

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

@@ -6,6 +6,10 @@ using System.Threading.Tasks;
 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;
 
 namespace gaseous_server.Controllers
 {
@@ -16,6 +20,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]
@@ -42,11 +55,14 @@ 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
+            {
+                if (GameId == -1 || filtered == false)
                 {
                     IGDB.Models.Platform platform = Classes.Metadata.Platforms.GetPlatform(PlatformId);
 
@@ -66,6 +82,33 @@ namespace gaseous_server.Controllers
                     var stream = new FileStream(tempFile, FileMode.Open);
                     return File(stream, "application/zip", platform.Slug + ".zip");
                 }
+                else
+                {
+                    // get user platform map
+                    var user = await _userManager.GetUserAsync(User);
+
+                    PlatformMapping platformMapping = new PlatformMapping();
+                    PlatformMapping.PlatformMapItem userPlatformMap = platformMapping.GetUserPlatformMap(user.Id, PlatformId, GameId);
+
+                    // build zip file
+                    string tempFile = Path.GetTempFileName();
+
+                    using (FileStream zipFile = System.IO.File.Create(tempFile))
+                    using (var zipArchive = new ZipArchive(zipFile, ZipArchiveMode.Create))
+                    {
+                        foreach (Bios.BiosItem bios in GetBios(PlatformId, true))
+                        {
+                            if (userPlatformMap.EnabledBIOSHashes.Contains(bios.hash))
+                            {
+                                zipArchive.CreateEntryFromFile(bios.biosPath, bios.filename);
+                            }
+                        }
+                    }
+
+                    var stream = new FileStream(tempFile, FileMode.Open);
+                    return File(stream, "application/zip", userPlatformMap.IGDBSlug + ".zip");
+                }
+            }
             catch
             {
                 return NotFound();

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

@@ -3,9 +3,12 @@ using System.Collections.Generic;
 using System.IO.Compression;
 using System.Linq;
 using System.Threading.Tasks;
+using Authentication;
 using gaseous_server.Classes;
 using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -16,6 +19,17 @@ namespace gaseous_server.Controllers
     [Authorize]
     public class CollectionsController : Controller
     {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+
+        public CollectionsController(
+            UserManager<ApplicationUser> userManager,
+            SignInManager<ApplicationUser> signInManager)
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+        }
+        
         /// <summary>
         /// Gets all ROM collections
         /// </summary>
@@ -24,9 +38,16 @@ namespace gaseous_server.Controllers
         [MapToApiVersion("1.1")]
         [HttpGet]
         [ProducesResponseType(StatusCodes.Status200OK)]
-        public List<Classes.Collections.CollectionItem> GetCollections()
+        public async Task<ActionResult> GetCollectionsAsync()
         {
-            return Classes.Collections.GetCollections();
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user != null)
+            {
+                return Ok(Classes.Collections.GetCollections(user.Id));
+            }
+
+            return NotFound();
         }
 
         /// <summary>
@@ -41,22 +62,31 @@ namespace gaseous_server.Controllers
         [Route("{CollectionId}")]
         [ProducesResponseType(typeof(Classes.Collections.CollectionItem), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollection(long CollectionId, bool Build = false)
+        public async Task<ActionResult> GetCollection(long CollectionId, bool Build = false)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user != null)
             {
                 try
                 {
                     if (Build == true)
                     {
-                    Classes.Collections.StartCollectionItemBuild(CollectionId);
+                        Classes.Collections.StartCollectionItemBuild(CollectionId, user.Id);
                     }
 
-                return Ok(Classes.Collections.GetCollection(CollectionId));
+                    return Ok(Classes.Collections.GetCollection(CollectionId, user.Id));
                 }
                 catch
                 {
                     return NotFound();
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
 
         /// <summary>
         /// Gets the contents of the specified ROM collection
@@ -69,18 +99,27 @@ namespace gaseous_server.Controllers
         [Route("{CollectionId}/Roms")]
         [ProducesResponseType(typeof(List<Classes.Collections.CollectionContents.CollectionPlatformItem>), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollectionRoms(long CollectionId)
+        public async Task<ActionResult> GetCollectionRoms(long CollectionId)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user != null)
             {
                 try
                 {
-                Classes.Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId);
+                    Classes.Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId, user.Id);
-                return Ok(Classes.Collections.GetCollectionContent(collectionItem));
+                    return Ok(Classes.Collections.GetCollectionContent(collectionItem, user.Id));
                 }
                 catch
                 {
                     return NotFound();
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
 
         /// <summary>
         /// Gets a preview of the provided collection item
@@ -94,17 +133,26 @@ namespace gaseous_server.Controllers
         [Authorize(Roles = "Admin,Gamer")]
         [ProducesResponseType(typeof(List<Classes.Collections.CollectionContents.CollectionPlatformItem>), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollectionRomsPreview(Classes.Collections.CollectionItem Item)
+        public async Task<ActionResult> GetCollectionRomsPreview(Classes.Collections.CollectionItem Item)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user != null)
             {
                 try
                 {
-                return Ok(Classes.Collections.GetCollectionContent(Item));
+                    return Ok(Classes.Collections.GetCollectionContent(Item, user.Id));
                 }
                 catch (Exception ex)
                 {
                 return NotFound(ex);
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
 
         /// <summary>
         /// Gets ROM collection in zip format
@@ -117,11 +165,15 @@ namespace gaseous_server.Controllers
         [Route("{CollectionId}/Roms/Zip")]
         [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollectionRomsZip(long CollectionId)
+        public async Task<ActionResult> GetCollectionRomsZip(long CollectionId)
+        {
+            var user = await _userManager.GetUserAsync(User);
+
+            if (user != null)
             {
                 try
                 {
-                Classes.Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId);
+                    Classes.Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId, user.Id);
 
                     string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, CollectionId + ".zip");
 
@@ -140,6 +192,11 @@ namespace gaseous_server.Controllers
                     return NotFound();
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
 
         /// <summary>
         /// Creates a new ROM collection
@@ -152,17 +209,26 @@ namespace gaseous_server.Controllers
         [Authorize(Roles = "Admin,Gamer")]
         [ProducesResponseType(typeof(Classes.Collections.CollectionItem), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        public ActionResult NewCollection(Classes.Collections.CollectionItem Item)
+        public async Task<ActionResult> NewCollectionAsync(Classes.Collections.CollectionItem Item)
+        {
+            var user = await _userManager.GetUserAsync(User);
+            
+            if (user != null)
             {
                 try
                 {
-                return Ok(Classes.Collections.NewCollection(Item));
+                    return Ok(Classes.Collections.NewCollection(Item, user.Id));
                 }
                 catch (Exception ex)
                 {
                     return BadRequest(ex);
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
 
         /// <summary>
         /// Edits an existing collection
@@ -177,17 +243,26 @@ namespace gaseous_server.Controllers
         [Authorize(Roles = "Admin,Gamer")]
         [ProducesResponseType(typeof(Classes.Collections.CollectionItem), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult EditCollection(long CollectionId, Classes.Collections.CollectionItem Item)
+        public async Task<ActionResult> EditCollection(long CollectionId, Classes.Collections.CollectionItem Item)
+        {
+            var user = await _userManager.GetUserAsync(User);
+            
+            if (user != null)
             {
                 try
                 {
-                return Ok(Classes.Collections.EditCollection(CollectionId, Item, true));
+                    return Ok(Classes.Collections.EditCollection(CollectionId, Item, user.Id, true));
                 }
                 catch
                 {
                     return NotFound();
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
 
         /// <summary>
         /// Edits an existing collection
@@ -202,11 +277,15 @@ namespace gaseous_server.Controllers
         [Route("{CollectionId}/AlwaysInclude")]
         [ProducesResponseType(typeof(Classes.Collections.CollectionItem), StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult EditCollectionAlwaysInclude(long CollectionId, [FromQuery]bool Rebuild, [FromBody]Collections.CollectionItem.AlwaysIncludeItem Inclusion)
+        public async Task<ActionResult> EditCollectionAlwaysInclude(long CollectionId, [FromQuery]bool Rebuild, [FromBody]Collections.CollectionItem.AlwaysIncludeItem Inclusion)
+        {
+            var user = await _userManager.GetUserAsync(User);
+            
+            if (user != null)
             {
                 try
                 {
-                Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId);
+                    Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId, user.Id);
                     bool ItemFound = false;
                     foreach (Collections.CollectionItem.AlwaysIncludeItem includeItem in collectionItem.AlwaysInclude)
                     {
@@ -220,13 +299,18 @@ namespace gaseous_server.Controllers
                         collectionItem.AlwaysInclude.Add(Inclusion);
                     }
 
-                return Ok(Classes.Collections.EditCollection(CollectionId, collectionItem, Rebuild));
+                    return Ok(Classes.Collections.EditCollection(CollectionId, collectionItem, user.Id, Rebuild));
                 }
                 catch
                 {
                     return NotFound();
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
 
         /// <summary>
         /// Deletes the specified ROM collection
@@ -239,11 +323,15 @@ namespace gaseous_server.Controllers
         [Route("{CollectionId}")]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult DeleteCollection(long CollectionId)
+        public async Task<ActionResult> DeleteCollection(long CollectionId)
+        {
+            var user = await _userManager.GetUserAsync(User);
+            
+            if (user != null)
             {
                 try
                 {
-                Classes.Collections.DeleteCollection(CollectionId);
+                    Classes.Collections.DeleteCollection(CollectionId, user.Id);
                     return Ok();
                 }
                 catch
@@ -251,5 +339,10 @@ namespace gaseous_server.Controllers
                     return NotFound();
                 }
             }
+            else
+            {
+                return NotFound();
+            }
+        }
     }
 }

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

@@ -3,11 +3,14 @@ using System.Collections.Generic;
 using System.Data;
 using System.Linq;
 using System.Threading.Tasks;
+using Authentication;
 using gaseous_server.Classes;
 using IGDB.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -16,98 +19,29 @@ namespace gaseous_server.Controllers
     [ApiVersion("1.1")]
     [Authorize]
     [ApiController]
-    public class FilterController : ControllerBase
+    public class FilterController : Controller
     {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+        
+        public FilterController(
+            UserManager<ApplicationUser> userManager,
+            SignInManager<ApplicationUser> signInManager)
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+        }
+
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
         [ProducesResponseType(StatusCodes.Status200OK)]
         //[ResponseCache(CacheProfileName = "5Minute")]
-        public Dictionary<string, object> Filter()
+        public async Task<IActionResult> FilterAsync()
         {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            var user = await _userManager.GetUserAsync(User);
             
-            Dictionary<string, object> FilterSet = new Dictionary<string, object>();
+            return Ok(Filters.Filter(user.SecurityProfile.AgeRestrictionPolicy.MaximumAgeRestriction, user.SecurityProfile.AgeRestrictionPolicy.IncludeUnrated));
-
-            // platforms
-            List<FilterPlatform> platforms = new List<FilterPlatform>();
-            //string sql = "SELECT Platform.Id, Platform.Abbreviation, Platform.AlternativeName, Platform.`Name`, Platform.PlatformLogo, (SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.PlatformId = Platform.Id) AS RomCount FROM Platform HAVING RomCount > 0 ORDER BY `Name`";
-            string sql = "SELECT Platform.Id, Platform.Abbreviation, Platform.AlternativeName, Platform.`Name`, Platform.PlatformLogo, (SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.PlatformId = Platform.Id) AS RomCount, (SELECT COUNT(*) AS GameCount FROM (SELECT DISTINCT Games_Roms.GameId AS ROMGameId, Games_Roms.PlatformId FROM Games_Roms LEFT JOIN Game ON Game.Id = Games_Roms.GameId) Game WHERE Game.PlatformId = Platform.Id) AS GameCount FROM Platform HAVING RomCount > 0 ORDER BY `Name`";
-            DataTable dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                FilterPlatform platformItem = new FilterPlatform(Classes.Metadata.Platforms.GetPlatform((long)dr["id"]));
-                platformItem.RomCount = (int)(long)dr["RomCount"];
-                platformItem.GameCount = (int)(long)dr["GameCount"];
-                platforms.Add(platformItem);
-
-            }
-            FilterSet.Add("platforms", platforms);
-
-            // genres
-            List<Genre> genres = new List<Genre>();
-            sql = "SELECT DISTINCT Relation_Game_Genres.GenresId AS id, Genre.`Name` FROM Relation_Game_Genres JOIN Genre ON Relation_Game_Genres.GenresId = Genre.Id WHERE Relation_Game_Genres.GameId IN (SELECT DISTINCT GameId FROM Games_Roms) ORDER BY `Name`;";
-            dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                genres.Add(Classes.Metadata.Genres.GetGenres((long)dr["id"]));
-            }
-            FilterSet.Add("genres", genres);
-
-            // game modes
-            List<GameMode> gameModes = new List<GameMode>();
-            sql = "SELECT DISTINCT Relation_Game_GameModes.GameModesId AS id, GameMode.`Name` FROM Relation_Game_GameModes JOIN GameMode ON Relation_Game_GameModes.GameModesId = GameMode.Id WHERE Relation_Game_GameModes.GameId IN (SELECT DISTINCT GameId FROM Games_Roms) ORDER BY `Name`;";
-            dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                gameModes.Add(Classes.Metadata.GameModes.GetGame_Modes((long)dr["id"]));
-            }
-            FilterSet.Add("gamemodes", gameModes);
-
-            // player perspectives
-            List<PlayerPerspective> playerPerspectives = new List<PlayerPerspective>();
-            sql = "SELECT DISTINCT Relation_Game_PlayerPerspectives.PlayerPerspectivesId AS id, PlayerPerspective.`Name` FROM Relation_Game_PlayerPerspectives JOIN PlayerPerspective ON Relation_Game_PlayerPerspectives.PlayerPerspectivesId = PlayerPerspective.Id WHERE Relation_Game_PlayerPerspectives.GameId IN (SELECT DISTINCT GameId FROM Games_Roms) ORDER BY `Name`;";
-            dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                playerPerspectives.Add(Classes.Metadata.PlayerPerspectives.GetGame_PlayerPerspectives((long)dr["id"]));
-            }
-            FilterSet.Add("playerperspectives", playerPerspectives);
-
-            // themes
-            List<Theme> themes = new List<Theme>();
-            sql = "SELECT DISTINCT Relation_Game_Themes.ThemesId AS id, Theme.`Name` FROM Relation_Game_Themes JOIN Theme ON Relation_Game_Themes.ThemesId = Theme.Id WHERE Relation_Game_Themes.GameId IN (SELECT DISTINCT GameId FROM Games_Roms) ORDER BY `Name`;";
-            dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                themes.Add(Classes.Metadata.Themes.GetGame_Themes((long)dr["id"]));
-            }
-            FilterSet.Add("themes", themes);
-
-            return FilterSet;
-        }
-
-        public class FilterPlatform : IGDB.Models.Platform
-        {
-            public FilterPlatform(Platform platform)
-            {
-                var properties = platform.GetType().GetProperties();
-                foreach (var prop in properties)
-                {
-                    if (prop.GetGetMethod() != null)
-                    {
-                        this.GetType().GetProperty(prop.Name).SetValue(this, prop.GetValue(platform));
-                    }
-                }
-            }
-
-            public int RomCount { get; set; }
-            public int GameCount { get; set; }
         }
     }
 }

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

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -85,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/LogsController.cs

@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using gaseous_server.Classes;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -17,11 +18,11 @@ namespace gaseous_server.Controllers
     {
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
-        [HttpGet]
+        [HttpPost]
         [ProducesResponseType(StatusCodes.Status200OK)]
-        public List<Logging.LogItem> Logs(long? StartIndex, int PageNumber = 1, int PageSize = 100)
+        public List<Logging.LogItem> Logs(Logging.LogsViewModel model)
         {
-            return Logging.GetLogs(StartIndex, PageNumber, PageSize);
+            return Logging.GetLogs(model);
         }
     }
 }

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

@@ -13,6 +13,8 @@ using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.CodeAnalysis.Scripting;
 using Microsoft.AspNetCore.Authorization;
+using System.Text;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -37,6 +39,32 @@ namespace gaseous_server.Controllers
             return Ok(PlatformMapping.PlatformMap);
         }
 
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("PlatformMap.json")]
+        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        public ActionResult DownloadPlatformMap()
+        {
+            string srcJson = Newtonsoft.Json.JsonConvert.SerializeObject(PlatformMapping.PlatformMap, Newtonsoft.Json.Formatting.Indented);
+
+            string filename = "PlatformMap.json";
+            byte[] bytes = Encoding.UTF8.GetBytes(srcJson);
+            string contentType = "application/json";
+
+            var cd = new System.Net.Mime.ContentDisposition
+            {
+                FileName = filename,
+                Inline = true,
+                DispositionType = "attachment"
+            };
+
+            Response.Headers.Add("Content-Disposition", cd.ToString());
+
+            return File(bytes, contentType);
+        }
+
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
@@ -121,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

@@ -13,6 +13,7 @@ using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.CodeAnalysis.Scripting;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -113,22 +114,64 @@ namespace gaseous_server.Controllers
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
-        [Route("{PlatformId}/platformlogo/image")]
+        [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);
-
+                IGDB.Models.PlatformLogo? logoObject = null;
-                string logoFilePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject), "Logo_Medium.png");
+                try
-                if (System.IO.File.Exists(logoFilePath))
                 {
-                    string filename = "Logo.png";
+                    logoObject = PlatformLogos.GetPlatformLogo(platformObject.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject));
-                    string filepath = logoFilePath;
+                }
-                    byte[] filedata = System.IO.File.ReadAllBytes(filepath);
+                catch
-                    string contentType = "image/png";
+                {
+                    // getting the logo failed, so we'll try a platform variant if available
+                    if (platformObject.Versions != null)
+                    {
+                        if (platformObject.Versions.Ids.Length > 0)
+                        {
+                            IGDB.Models.PlatformVersion platformVersion = Classes.Metadata.PlatformVersions.GetPlatformVersion(platformObject.Versions.Ids[0], platformObject);
+                            logoObject = PlatformLogos.GetPlatformLogo(platformVersion.PlatformLogo.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject));
+                        }
+                        else
+                        {
+                            return NotFound();
+                        }
+                    }
+                    else
+                    {
+                        return NotFound();
+                    }
+                }
+
+                string basePath = Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(platformObject));
+                string imagePath = Path.Combine(basePath, size.ToString(), logoObject.ImageId + ".jpg");
+
+                if (!System.IO.File.Exists(imagePath))
+                {
+                    Communications comms = new Communications();
+                    Task<string> ImgFetch = comms.GetSpecificImageFromServer(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(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))
+                {
+                    string filename = logoObject.ImageId + ".jpg";
+                    string filepath = imagePath;
+                    string contentType = "image/jpg";
 
                     var cd = new System.Net.Mime.ContentDisposition
                     {
@@ -137,14 +180,22 @@ 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);
                 }
-                else
+
-                {
                 return NotFound();
             }
-            }
             catch
             {
                 return NotFound();

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

@@ -14,6 +14,7 @@ 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
 {
@@ -22,7 +23,7 @@ namespace gaseous_server.Controllers
     [ApiVersion("1.1")]
     [Authorize]
     [ApiController]
-    public class RomsController : ControllerBase
+    public class RomsController : Controller
     {
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
@@ -30,41 +31,34 @@ 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);
+            if (file.Length > 0)
-
-            List<Dictionary<string, object>> UploadedFiles = new List<Dictionary<string, object>>();
-
-            foreach (IFormFile formFile in files)
-            {
-                if (formFile.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
@@ -74,10 +68,22 @@ namespace gaseous_server.Controllers
                     OverridePlatform = Platforms.GetPlatform((long)OverridePlatformId);
                 }
 
-            // Process uploaded files
+                // Process uploaded file
-            foreach (Dictionary<string, object> UploadedFile in UploadedFiles)
+                Classes.ImportGame uploadImport = new ImportGame();
+                Dictionary<string, object> RetVal = uploadImport.ImportGameFile((string)UploadedFile["fullpath"], OverridePlatform);
+                switch (RetVal["type"])
                 {
-                Classes.ImportGame.ImportGameFile((string)UploadedFile["fullpath"], OverridePlatform);
+                    case "rom":
+                        if (RetVal["status"] == "imported")
+                        {
+                            IGDB.Models.Game? game = (IGDB.Models.Game)RetVal["game"];
+                            if (game.Id == null)
+                            {
+                                RetVal["game"] = Games.GetGame(0, false, false, false);
+                            }
+                        }
+                        break;
+
                 }
 
                 if (Directory.Exists(workPath))
@@ -85,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

@@ -1,14 +1,18 @@
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Threading.Tasks;
 using gaseous_server.Classes;
+using gaseous_server.Classes.Metadata;
+using gaseous_server.Models;
 using IGDB;
 using IGDB.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using NuGet.Common;
 using static gaseous_server.Classes.Metadata.Games;
-
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -19,12 +23,6 @@ namespace gaseous_server.Controllers
     [Authorize]
     public class SearchController : Controller
     {
-        private static IGDBClient igdb = new IGDBClient(
-                            // Found in Twitch Developer portal for your app
-                            Config.IGDB.ClientId,
-                            Config.IGDB.Secret
-                        );
-
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
@@ -39,37 +37,92 @@ namespace gaseous_server.Controllers
         private static async Task<List<Platform>> _SearchForPlatform(string SearchString)
         {
             string searchBody = "";
-            searchBody += "fields abbreviation,alternative_name,category,checksum,created_at,generation,name,platform_family,platform_logo,slug,summary,updated_at,url,versions,websites; ";
+            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 + "\"*;";
 
-            // get Platform metadata
+            List<Platform>? searchCache = Communications.GetSearchCache<List<Platform>>(searchFields, searchBody);
-            var results = await igdb.QueryAsync<Platform>(IGDBClient.Endpoints.Platforms, query: searchBody);
+
+            if (searchCache == null)
+            {
+                // cache miss
+                // get Platform metadata from data source
+                Communications comms = new Communications();
+                var results = await comms.APIComm<Platform>(IGDBClient.Endpoints.Platforms, searchFields, searchBody);
+
+                Communications.SetSearchCache<List<Platform>>(searchFields, searchBody, results.ToList());
 
                 return results.ToList();
             }
+            else
+            {
+                return searchCache;
+            }
+        }
 
         [MapToApiVersion("1.0")]
         [MapToApiVersion("1.1")]
         [HttpGet]
         [Route("Game")]
-        [ProducesResponseType(typeof(List<Game>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(List<GaseousGame>), StatusCodes.Status200OK)]
         public async Task<ActionResult> SearchGame(long PlatformId, string SearchString)
         {
-            List<Game> RetVal = await _SearchForGame(PlatformId, SearchString);
+            List<GaseousGame> RetVal = await _SearchForGame(PlatformId, SearchString);
             return Ok(RetVal);
         }
 
-        private static async Task<List<Game>> _SearchForGame(long PlatformId, string SearchString)
+        private static async Task<List<GaseousGame>> _SearchForGame(long PlatformId, string SearchString)
         {
             string searchBody = "";
-            searchBody += "fields cover.*,first_release_date,name,platforms,slug; ";
+            string searchFields = "fields *; ";
             searchBody += "search \"" + SearchString + "\";";
             searchBody += "where platforms = (" + PlatformId + ");";
+            searchBody += "limit 100;";
 
-            // get Platform metadata
+            List<GaseousGame>? searchCache = Communications.GetSearchCache<List<GaseousGame>>(searchFields, searchBody);
-            var results = await igdb.QueryAsync<Game>(IGDBClient.Endpoints.Games, query: searchBody);
 
-            return results.ToList();
+            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);
+
+                List<GaseousGame> games = new List<GaseousGame>();
+                foreach (Game game in results.ToList())
+                {
+                    Storage.CacheStatus cacheStatus = Storage.GetCacheStatus("Game", (long)game.Id);
+                    switch (cacheStatus)
+                    {
+                        case Storage.CacheStatus.NotPresent:
+                            Storage.NewCacheValue(game, false);
+                            break;
+
+                        case Storage.CacheStatus.Expired:
+                            Storage.NewCacheValue(game, true);
+                            break;
+
+                    }
+
+                    games.Add(new GaseousGame(game));
+                }
+
+                Communications.SetSearchCache<List<GaseousGame>>(searchFields, searchBody, games);
+
+                return games;
+            }
+            else
+            {
+                // 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)
+                {
+                    Game tempGame = Games.GetGame((long)game.Id, false, false, false);
+                    gamesToReturn.Add(new GaseousGame(tempGame));
+                }
+
+                return gamesToReturn;
+            }
         }
     }
 }

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

@@ -8,6 +8,8 @@ using gaseous_server.Classes;
 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
 
@@ -18,7 +20,7 @@ namespace gaseous_server.Controllers
     [ApiVersion("1.0")]
     [ApiVersion("1.1")]
     [Authorize]
-    public class SignaturesController : ControllerBase
+    public class SignaturesController : Controller
     {
         /// <summary>
         /// Get the current signature counts from the database
@@ -37,14 +39,26 @@ namespace gaseous_server.Controllers
         [MapToApiVersion("1.1")]
         [HttpGet]
         [ProducesResponseType(StatusCodes.Status200OK)]
-        public List<Models.Signatures_Games> GetSignature(string md5 = "", string sha1 = "")
+        public List<gaseous_server.Models.Signatures_Games> GetSignature(string md5 = "", string sha1 = "")
         {
-            if (md5.Length > 0)
+            SignatureManagement signatureManagement = new SignatureManagement();
+            return signatureManagement.GetSignature(md5, sha1);
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public List<gaseous_server.Models.Signatures_Games> GetByTosecName(string TosecName = "")
         {
-                return _GetSignature("Signatures_Roms.md5 = @searchstring", md5);
+            if (TosecName.Length > 0)
-            } else
             {
-                return _GetSignature("Signatures_Roms.sha1 = @searchstring", sha1);
+                SignatureManagement signatureManagement = new SignatureManagement();
+                return signatureManagement.GetByTosecName(TosecName);
+            }
+            else
+            {
+                return null;
             }
         }
 
@@ -52,66 +66,22 @@ namespace gaseous_server.Controllers
         [MapToApiVersion("1.1")]
         [HttpGet]
         [ProducesResponseType(StatusCodes.Status200OK)]
-        public List<Models.Signatures_Games> GetByTosecName(string TosecName = "")
+        public List<Signatures_Sources> GetSignatureSources()
         {
-            if (TosecName.Length > 0)
+            SignatureManagement signatureManagement = new SignatureManagement();
-            {
+            return signatureManagement.GetSources();
-                return _GetSignature("Signatures_Roms.name = @searchstring", TosecName);
-            } else
-            {
-                return null;
-            }
         }
 
-        private List<Models.Signatures_Games> _GetSignature(string sqlWhere, string searchString)
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpDelete]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public IActionResult DeleteSignatureSource(int Id)
         {
-            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            SignatureManagement signatureManagement = new SignatureManagement();
-            string sql = "SELECT     view_Signatures_Games.*,    Signatures_Roms.Id AS romid,    Signatures_Roms.Name AS romname,    Signatures_Roms.Size,    Signatures_Roms.CRC,    Signatures_Roms.MD5,    Signatures_Roms.SHA1,    Signatures_Roms.DevelopmentStatus,    Signatures_Roms.Attributes,    Signatures_Roms.RomType,    Signatures_Roms.RomTypeMedia,    Signatures_Roms.MediaLabel,    Signatures_Roms.MetadataSource FROM    Signatures_Roms        INNER JOIN    view_Signatures_Games ON Signatures_Roms.GameId = view_Signatures_Games.Id WHERE " + sqlWhere;
+            signatureManagement.DeleteSource(Id);
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("searchString", searchString);
 
-            DataTable sigDb = db.ExecuteCMD(sql, dbDict);
+            return Ok();
-
-            List<Models.Signatures_Games> GamesList = new List<Models.Signatures_Games>();
-
-            foreach (DataRow sigDbRow in sigDb.Rows)
-            {
-                Models.Signatures_Games gameItem = new Models.Signatures_Games
-                {
-                    Game = new Models.Signatures_Games.GameItem
-                    {
-                        Id = (Int32)sigDbRow["Id"],
-                        Name = (string)sigDbRow["Name"],
-                        Description = (string)sigDbRow["Description"],
-                        Year = (string)sigDbRow["Year"],
-                        Publisher = (string)sigDbRow["Publisher"],
-                        Demo = (Models.Signatures_Games.GameItem.DemoTypes)(int)sigDbRow["Demo"],
-                        System = (string)sigDbRow["Platform"],
-                        SystemVariant = (string)sigDbRow["SystemVariant"],
-                        Video = (string)sigDbRow["Video"],
-                        Country = (string)sigDbRow["Country"],
-                        Language = (string)sigDbRow["Language"],
-                        Copyright = (string)sigDbRow["Copyright"]
-                    },
-                    Rom = new Models.Signatures_Games.RomItem
-                    {
-                        Id = (Int32)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"], "[]")),
-                        RomType = (RomSignatureObject.Game.Rom.RomTypes)(int)sigDbRow["RomType"],
-                        RomTypeMedia = (string)sigDbRow["RomTypeMedia"],
-                        MediaLabel = (string)sigDbRow["MediaLabel"],
-                        SignatureSource = (gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType)(Int32)sigDbRow["MetadataSource"]
-                    }
-                };
-                GamesList.Add(gameItem);
-            }
-            return GamesList;
         }
     }
 }

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

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Data;
 using System.Linq;
 using System.Reflection;
+using System.Security.Cryptography.X509Certificates;
 using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -10,6 +11,9 @@ using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Razor.Hosting;
+using RestEase;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
@@ -34,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;
 
@@ -66,7 +73,8 @@ namespace gaseous_server.Controllers
         [HttpGet]
         [Route("Version")]
         [ProducesResponseType(StatusCodes.Status200OK)]
-        public Version GetSystemVersion() {
+        public Version GetSystemVersion()
+        {
             return Assembly.GetExecutingAssembly().GetName().Version;
         }
 
@@ -76,10 +84,17 @@ 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
+            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)))
             {
@@ -88,20 +103,206 @@ 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("FirstRunStatus", "0") + ";" + Environment.NewLine +
+                "var FirstRunStatus = \"" + Config.ReadSetting<string>("FirstRunStatus", "0") + "\";" + Environment.NewLine +
-                "var AgeRatingStrings = " + JsonSerializer.Serialize(AgeRatingsStrings, new JsonSerializerOptions{
+                "var AgeRatingBoardsStrings = " + JsonSerializer.Serialize(ClassificationBoardsStrings, new JsonSerializerOptions
+                {
                     WriteIndented = true
                 }) + ";" + Environment.NewLine +
-                "var AgeRatingGroups = " + JsonSerializer.Serialize(AgeRatings.AgeGroups.AgeGroupingsFlat, new JsonSerializerOptions{
+                "var AgeRatingStrings = " + JsonSerializer.Serialize(AgeRatingsStrings, new JsonSerializerOptions
+                {
                     WriteIndented = true
-                }) + ";";
+                }) + ";" + Environment.NewLine +
+                "var AgeRatingGroups = " + JsonSerializer.Serialize(AgeGroups.AgeGroupingsFlat, new JsonSerializerOptions
+                {
+                    WriteIndented = true
+                }) + ";" + Environment.NewLine +
+                "var emulatorDebugMode = " + Config.ReadSetting<string>("emulatorDebugMode", false.ToString()).ToLower() + ";";
             byte[] bytes = Encoding.UTF8.GetBytes(ver);
             return File(bytes, "text/javascript");
         }
 
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("Settings/BackgroundTasks/Configuration")]
+        [Authorize(Roles = "Admin")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public ActionResult GetBackgroundTasks()
+        {
+            Dictionary<string, BackgroundTaskItem> Intervals = new Dictionary<string, BackgroundTaskItem>();
+            foreach (ProcessQueue.QueueItemType itemType in Enum.GetValues(typeof(ProcessQueue.QueueItemType)))
+            {
+                BackgroundTaskItem taskItem = new BackgroundTaskItem(itemType);
+                if (taskItem.UserManageable == true)
+                {
+                    if (!Intervals.ContainsKey(itemType.ToString()))
+                    {
+                        Intervals.Add(itemType.ToString(), taskItem);
+                    }
+                }
+            }
+
+            return Ok(Intervals);
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost]
+        [Route("Settings/BackgroundTasks/Configuration")]
+        [Authorize(Roles = "Admin")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public ActionResult SetBackgroundTasks([FromBody] List<BackgroundTaskSettingsItem> model)
+        {
+            foreach (BackgroundTaskSettingsItem TaskConfiguration in model)
+            {
+                if (Enum.IsDefined(typeof(ProcessQueue.QueueItemType), TaskConfiguration.Task))
+                {
+                    try
+                    {
+                        BackgroundTaskItem taskItem = new BackgroundTaskItem(
+                            (ProcessQueue.QueueItemType)Enum.Parse(typeof(ProcessQueue.QueueItemType), TaskConfiguration.Task)
+                        );
+
+                        if (taskItem.UserManageable == true)
+                        {
+                            // update task enabled
+                            Logging.Log(Logging.LogType.Information, "Update Background Task", "Updating task " + TaskConfiguration.Task + " with enabled value " + TaskConfiguration.Enabled.ToString());
+
+                            Config.SetSetting<string>("Enabled_" + TaskConfiguration.Task, TaskConfiguration.Enabled.ToString());
+
+                            // update existing process
+                            foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+                            {
+                                if (item.ItemType.ToString().ToLower() == TaskConfiguration.Task.ToLower())
+                                {
+                                    item.Enabled(Boolean.Parse(TaskConfiguration.Enabled.ToString()));
+                                }
+                            }
+
+                            // update task interval
+                            if (TaskConfiguration.Interval >= taskItem.MinimumAllowedInterval)
+                            {
+                                Logging.Log(Logging.LogType.Information, "Update Background Task", "Updating task " + TaskConfiguration.Task + " with new interval " + TaskConfiguration.Interval);
+
+                                Config.SetSetting<string>("Interval_" + TaskConfiguration.Task, TaskConfiguration.Interval.ToString());
+
+                                // update existing process
+                                foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+                                {
+                                    if (item.ItemType.ToString().ToLower() == TaskConfiguration.Task.ToLower())
+                                    {
+                                        item.Interval = TaskConfiguration.Interval;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                Logging.Log(Logging.LogType.Warning, "Update Background Task", "Interval " + TaskConfiguration.Interval.ToString() + " for task " + TaskConfiguration.Task + " is below the minimum allowed value of " + taskItem.MinimumAllowedInterval + ". Skipping.");
+                            }
+
+                            // update task weekdays
+                            Logging.Log(Logging.LogType.Information, "Update Background Task", "Updating task " + TaskConfiguration.Task + " with new weekdays " + String.Join(", ", TaskConfiguration.AllowedDays));
+
+                            Config.SetSetting<string>("AllowedDays_" + TaskConfiguration.Task, Newtonsoft.Json.JsonConvert.SerializeObject(TaskConfiguration.AllowedDays));
+
+                            // update existing process
+                            foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+                            {
+                                if (item.ItemType.ToString().ToLower() == TaskConfiguration.Task.ToLower())
+                                {
+                                    item.AllowedDays = TaskConfiguration.AllowedDays;
+                                }
+                            }
+
+                            // update task hours
+                            Logging.Log(Logging.LogType.Information, "Update Background Task", "Updating task " + TaskConfiguration.Task + " with new hours " + TaskConfiguration.AllowedStartHours + ":" + TaskConfiguration.AllowedStartMinutes.ToString("00") + " to " + TaskConfiguration.AllowedEndHours + ":" + TaskConfiguration.AllowedEndMinutes.ToString("00"));
+
+                            Config.SetSetting<string>("AllowedStartHours_" + TaskConfiguration.Task, TaskConfiguration.AllowedStartHours.ToString());
+                            Config.SetSetting<string>("AllowedStartMinutes_" + TaskConfiguration.Task, TaskConfiguration.AllowedStartMinutes.ToString());
+                            Config.SetSetting<string>("AllowedEndHours_" + TaskConfiguration.Task, TaskConfiguration.AllowedEndHours.ToString());
+                            Config.SetSetting<string>("AllowedEndMinutes_" + TaskConfiguration.Task, TaskConfiguration.AllowedEndMinutes.ToString());
+
+                            // update existing process
+                            foreach (ProcessQueue.QueueItem item in ProcessQueue.QueueItems)
+                            {
+                                if (item.ItemType.ToString().ToLower() == TaskConfiguration.Task.ToLower())
+                                {
+                                    item.AllowedStartHours = TaskConfiguration.AllowedStartHours;
+                                    item.AllowedStartMinutes = TaskConfiguration.AllowedStartMinutes;
+                                    item.AllowedEndHours = TaskConfiguration.AllowedEndHours;
+                                    item.AllowedEndMinutes = TaskConfiguration.AllowedEndMinutes;
+                                }
+                            }
+
+                        }
+                        else
+                        {
+                            Logging.Log(Logging.LogType.Warning, "Update Background Task", "Unable to update non-user manageable task " + TaskConfiguration.Task + ". Skipping.");
+                        }
+                    }
+                    catch
+                    {
+                        // task name not defined
+                        Logging.Log(Logging.LogType.Warning, "Update Background Task", "Task " + TaskConfiguration.Task + " is not user definable. Skipping.");
+                    }
+                }
+            }
+
+            return Ok();
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpGet]
+        [Route("Settings/System")]
+        [Authorize(Roles = "Admin")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public ActionResult GetSystemSettings()
+        {
+            SystemSettingsModel systemSettingsModel = new SystemSettingsModel
+            {
+                AlwaysLogToDisk = Config.LoggingConfiguration.AlwaysLogToDisk,
+                MinimumLogRetentionPeriod = Config.LoggingConfiguration.LogRetention,
+                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
+                }
+            };
+
+            return Ok(systemSettingsModel);
+        }
+
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
+        [HttpPost]
+        [Route("Settings/System")]
+        [Authorize(Roles = "Admin")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public ActionResult SetSystemSettings(SystemSettingsModel model)
+        {
+            if (ModelState.IsValid)
+            {
+                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;
+                Config.UpdateConfig();
+            }
+
+            return Ok(model);
+        }
+
         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,
@@ -113,7 +314,8 @@ namespace gaseous_server.Controllers
 
         public class SystemInfo
         {
-            public Version ApplicationVersion { 
+            public Version ApplicationVersion
+            {
                 get
                 {
                     return Assembly.GetExecutingAssembly().GetName().Version;
@@ -125,6 +327,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; }
@@ -139,4 +342,406 @@ namespace gaseous_server.Controllers
             }
         }
     }
+
+    public class BackgroundTaskItem
+    {
+        public BackgroundTaskItem()
+        {
+
+        }
+
+        public BackgroundTaskItem(ProcessQueue.QueueItemType TaskName)
+        {
+            this.Task = TaskName.ToString();
+            this.TaskEnum = TaskName;
+
+            switch (TaskName)
+            {
+                case ProcessQueue.QueueItemType.SignatureIngestor:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 60;
+                    this.MinimumAllowedInterval = 20;
+                    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;
+                    break;
+
+                case ProcessQueue.QueueItemType.TitleIngestor:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 1;
+                    this.MinimumAllowedInterval = 1;
+                    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
+                    };
+                    break;
+
+                case ProcessQueue.QueueItemType.MetadataRefresh:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 360;
+                    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;
+                    break;
+
+                case ProcessQueue.QueueItemType.OrganiseLibrary:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 1440;
+                    this.MinimumAllowedInterval = 120;
+                    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.LibraryScan,
+                        ProcessQueue.QueueItemType.LibraryScanWorker,
+                        ProcessQueue.QueueItemType.TitleIngestor,
+                        ProcessQueue.QueueItemType.Rematcher
+                    };
+                    break;
+
+                case ProcessQueue.QueueItemType.LibraryScan:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 1440;
+                    this.MinimumAllowedInterval = 120;
+                    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.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
+                    };
+                    break;
+
+                case ProcessQueue.QueueItemType.DailyMaintainer:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 1440;
+                    this.MinimumAllowedInterval = 1440;
+                    this.DefaultAllowedDays = new List<DayOfWeek>{
+                        DayOfWeek.Sunday,
+                        DayOfWeek.Monday,
+                        DayOfWeek.Tuesday,
+                        DayOfWeek.Wednesday,
+                        DayOfWeek.Thursday,
+                        DayOfWeek.Friday,
+                        DayOfWeek.Saturday
+                    };
+                    this.DefaultAllowedStartHours = 1;
+                    this.DefaultAllowedStartMinutes = 0;
+                    this.DefaultAllowedEndHours = 5;
+                    this.DefaultAllowedEndMinutes = 59;
+                    this._Blocks = new List<ProcessQueue.QueueItemType>{
+                        ProcessQueue.QueueItemType.All
+                    };
+                    break;
+
+                case ProcessQueue.QueueItemType.WeeklyMaintainer:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 10080;
+                    this.MinimumAllowedInterval = 10080;
+                    this.DefaultAllowedDays = new List<DayOfWeek>{
+                        DayOfWeek.Monday
+                    };
+                    this.DefaultAllowedStartHours = 1;
+                    this.DefaultAllowedStartMinutes = 0;
+                    this.DefaultAllowedEndHours = 5;
+                    this.DefaultAllowedEndMinutes = 59;
+                    this._Blocks = new List<ProcessQueue.QueueItemType>{
+                        ProcessQueue.QueueItemType.All
+                    };
+                    break;
+
+                case ProcessQueue.QueueItemType.BackgroundDatabaseUpgrade:
+                    this._UserManageable = false;
+                    this.DefaultInterval = 1;
+                    this.MinimumAllowedInterval = 1;
+                    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.Add(ProcessQueue.QueueItemType.All);
+                    break;
+
+                case ProcessQueue.QueueItemType.TempCleanup:
+                    this._UserManageable = true;
+                    this.DefaultInterval = 1;
+                    this.MinimumAllowedInterval = 1;
+                    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;
+                    break;
+
+                default:
+                    this._UserManageable = false;
+                    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;
+                    break;
+            }
+        }
+
+        public string Task { get; set; }
+        public ProcessQueue.QueueItemType TaskEnum { get; set; }
+        public bool Enabled
+        {
+            get
+            {
+                if (_UserManageable == true)
+                {
+                    return bool.Parse(Config.ReadSetting<string>("Enabled_" + Task, true.ToString()));
+                }
+                else
+                {
+                    return true;
+                }
+            }
+            set
+            {
+                if (_UserManageable == true)
+                {
+                    Config.SetSetting<string>("Enabled_" + Task, value.ToString());
+                }
+            }
+        }
+        private bool _UserManageable;
+        public bool UserManageable => _UserManageable;
+        public int Interval
+        {
+            get
+            {
+                return int.Parse(Config.ReadSetting<string>("Interval_" + Task, DefaultInterval.ToString()));
+            }
+        }
+        public int DefaultInterval { get; set; }
+        public int MinimumAllowedInterval { get; set; }
+        public List<DayOfWeek> AllowedDays
+        {
+            get
+            {
+                string jsonDefaultAllowedDays = Newtonsoft.Json.JsonConvert.SerializeObject(DefaultAllowedDays);
+                return Newtonsoft.Json.JsonConvert.DeserializeObject<List<DayOfWeek>>(Config.ReadSetting<string>("AllowedDays_" + Task, jsonDefaultAllowedDays));
+            }
+        }
+        public int AllowedStartHours
+        {
+            get
+            {
+                return int.Parse(Config.ReadSetting<string>("AllowedStartHours_" + Task, DefaultAllowedStartHours.ToString()));
+            }
+        }
+        public int AllowedStartMinutes
+        {
+            get
+            {
+                return int.Parse(Config.ReadSetting<string>("AllowedStartMinutes_" + Task, DefaultAllowedStartMinutes.ToString()));
+            }
+        }
+        public int AllowedEndHours
+        {
+            get
+            {
+                return int.Parse(Config.ReadSetting<string>("AllowedEndHours_" + Task, DefaultAllowedEndHours.ToString()));
+            }
+        }
+        public int AllowedEndMinutes
+        {
+            get
+            {
+                return int.Parse(Config.ReadSetting<string>("AllowedEndMinutes_" + Task, DefaultAllowedEndMinutes.ToString()));
+            }
+        }
+        public List<DayOfWeek> DefaultAllowedDays { get; set; }
+        public int DefaultAllowedStartHours { get; set; }
+        public int DefaultAllowedStartMinutes { get; set; }
+        public int DefaultAllowedEndHours { get; set; }
+        public int DefaultAllowedEndMinutes { get; set; }
+        private List<ProcessQueue.QueueItemType> _Blocks = new List<ProcessQueue.QueueItemType>();
+        public List<ProcessQueue.QueueItemType> Blocks
+        {
+            get
+            {
+                if (_Blocks.Contains(ProcessQueue.QueueItemType.All))
+                {
+                    List<ProcessQueue.QueueItemType> blockList = new List<ProcessQueue.QueueItemType>();
+                    List<ProcessQueue.QueueItemType> skipBlockItems = new List<ProcessQueue.QueueItemType>{
+                        ProcessQueue.QueueItemType.All,
+                        ProcessQueue.QueueItemType.NotConfigured,
+                        this.TaskEnum
+                    };
+                    foreach (ProcessQueue.QueueItemType blockType in Enum.GetValues(typeof(ProcessQueue.QueueItemType)))
+                    {
+                        if (!skipBlockItems.Contains(blockType))
+                        {
+                            blockList.Add(blockType);
+                        }
+                    }
+                    return blockList;
+                }
+                else
+                {
+                    return _Blocks;
+                }
+            }
+        }
+        public List<ProcessQueue.QueueItemType> BlockedBy
+        {
+            get
+            {
+                List<ProcessQueue.QueueItemType> blockedBy = new List<ProcessQueue.QueueItemType>();
+
+                List<BackgroundTaskItem> backgroundTaskItems = new List<BackgroundTaskItem>();
+                foreach (ProcessQueue.QueueItemType blockType in Enum.GetValues(typeof(ProcessQueue.QueueItemType)))
+                {
+                    if (blockType != this.TaskEnum)
+                    {
+                        BackgroundTaskItem taskItem = new BackgroundTaskItem(blockType);
+                        if (taskItem.Blocks.Contains(this.TaskEnum))
+                        {
+                            if (!blockedBy.Contains(blockType))
+                            {
+                                blockedBy.Add(blockType);
+                            }
+                        }
+                    }
+                }
+
+                return blockedBy;
+            }
+        }
+    }
+
+    public class BackgroundTaskSettingsItem
+    {
+        public string Task { get; set; }
+        public bool Enabled { get; set; }
+        public int Interval { get; set; }
+        public List<DayOfWeek> AllowedDays { get; set; }
+        public int AllowedStartHours { get; set; }
+        public int AllowedStartMinutes { get; set; }
+        public int AllowedEndHours { get; set; }
+        public int AllowedEndMinutes { get; set; }
+    }
+
+    public class SystemSettingsModel
+    {
+        public bool AlwaysLogToDisk { get; set; }
+        public int MinimumLogRetentionPeriod { get; set; }
+        public bool EmulatorDebugMode { get; set; }
+        public SignatureSourceItem SignatureSource { 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; }
+        }
+    }
 }

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();
+            }
+        }
+    }
+}