Fixed captialisation issue in sql query

* Fixed captialisation issue in sql query

.devcontainer/.env

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

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

.devcontainer/devcontainer.json

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

.devcontainer/docker-compose.yml

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

.github/dependabot.yml

@@ -9,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

@@ -33,6 +33,6 @@ jobs:
         uses: docker/build-push-action@v4
         with:
           context: .
-          platforms: linux/amd64 #,linux/arm64
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: gaseousgames/gaseousserver:${{ github.ref_name}}

.github/workflows/BuildDockerOnTag-Release.yml

@@ -32,6 +32,6 @@ jobs:
         uses: docker/build-push-action@v4
         with:
           context: .
-          platforms: linux/amd64 #,linux/arm64
+          platforms: linux/amd64,linux/arm64
           push: true
           tags: gaseousgames/gaseousserver:latest,gaseousgames/gaseousserver:${{ github.ref_name}}

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

.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,14 +10,14 @@
             "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"

Dockerfile

@@ -1,16 +1,28 @@
-FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build-env
+FROM --platform=$BUILDPLATFORM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
+ARG TARGETARCH
+ARG BUILDPLATFORM
 WORKDIR /App
 EXPOSE 80
 
+RUN echo "Target: $TARGETARCH"
+RUN echo "Build: $BUILDPLATFORM"
+
 # Copy everything
 COPY . ./
 # Restore as distinct layers
-RUN dotnet restore "gaseous-server/gaseous-server.csproj"
+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 false -c Release -o out
+RUN dotnet publish "gaseous-server/gaseous-server.csproj" --use-current-runtime --self-contained true -c Release -o out -a $TARGETARCH
+
+# download and unzip EmulatorJS from CDN
+RUN apt-get update && apt-get install -y p7zip-full
+RUN mkdir -p out/wwwroot/emulators/EmulatorJS
+RUN wget https://cdn.emulatorjs.org/releases/4.0.11.7z
+RUN 7z x -y -oout/wwwroot/emulators/EmulatorJS 4.0.11.7z
 
 # Build runtime image
-FROM mcr.microsoft.com/dotnet/aspnet:7.0
+FROM mcr.microsoft.com/dotnet/aspnet:8.0
+ENV INDOCKER=1
 WORKDIR /App
 COPY --from=build-env /App/out .
 ENTRYPOINT ["dotnet", "gaseous-server.dll"]

Gaseous.sln

@@ -1,11 +1,9 @@
-
+
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
 VisualStudioVersion = 25.0.1704.4
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-tools", "gaseous-tools\gaseous-tools.csproj", "{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "gaseous-server", "gaseous-server\gaseous-server.csproj", "{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}"
+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
@@ -37,10 +35,6 @@ Global
 		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FFCEC386-033F-4772-A45B-D33579F2E5EE}.Release|Any CPU.Build.0 = Release|Any CPU
-		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{08FE408A-5EC1-4110-ABD8-D19A1155B8CE}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A01D2EFF-C82E-473B-84D7-7C25E736F5D2}.Release|Any CPU.ActiveCfg = Release|Any CPU

README.MD

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

docker-compose-build.yml

@@ -14,6 +14,7 @@ services:
     volumes:
       - gs:/root/.gaseous-server
     environment:
+      - TZ=Australia/Sydney
       - dbhost=gsdb
       - dbuser=root
       - dbpass=gaseous
@@ -21,16 +22,16 @@ services:
       - igdbclientsecret=<clientsecret>
   gsdb:
     container_name: gsdb
-    image: mysql:8
+    image: mariadb
     restart: unless-stopped
     networks:
       - gaseous
     volumes:
       - gsdb:/var/lib/mysql
     environment:
-      - MYSQL_ROOT_PASSWORD=gaseous
-      - MYSQL_USER=gaseous
-      - MYSQL_PASSWORD=gaseous
+      - MARIADB_ROOT_PASSWORD=gaseous
+      - MARIADB_USER=gaseous
+      - MARIADB_PASSWORD=gaseous
 networks:
   gaseous:
     driver: bridge

docker-compose.yml

@@ -13,6 +13,7 @@ services:
     volumes:
       - gs:/root/.gaseous-server
     environment:
+      - TZ=Australia/Sydney
       - dbhost=gsdb
       - dbuser=root
       - dbpass=gaseous
@@ -20,16 +21,16 @@ services:
       - igdbclientsecret=<clientsecret>
   gsdb:
     container_name: gsdb
-    image: mysql:8
+    image: mariadb
     restart: unless-stopped
     networks:
       - gaseous
     volumes:
       - gsdb:/var/lib/mysql
     environment:
-      - MYSQL_ROOT_PASSWORD=gaseous
-      - MYSQL_USER=gaseous
-      - MYSQL_PASSWORD=gaseous
+      - MARIADB_ROOT_PASSWORD=gaseous
+      - MARIADB_USER=gaseous
+      - MARIADB_PASSWORD=gaseous
 networks:
   gaseous:
     driver: bridge

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gaseous-server/Classes/Bios.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
 using System.Security.Cryptography;
-using gaseous_tools;
 
 namespace gaseous_server.Classes
 {

gaseous-server/Classes/Collections.cs

@@ -4,27 +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 gaseous_tools;
 using IGDB.Models;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc.Filters;
 using Newtonsoft.Json;
+using SharpCompress.Common;
+using static gaseous_server.Classes.Metadata.Games;
 
 namespace gaseous_server.Classes
 {
 	public class Collections
 	{
-		public Collections()
-		{
-            
-		}
-
-        public static List<CollectionItem> GetCollections() {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "SELECT * FROM RomCollections ORDER BY `Name`";
-
-            DataTable data = db.ExecuteCMD(sql);
+        public static List<CollectionItem> GetCollections(string userid) {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM RomCollections WHERE OwnedBy=@ownedby ORDER BY `Name`";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>{
+                { "ownedby", userid }
+            };
+            DataTable data = db.ExecuteCMD(sql, dbDict);
 
             List<CollectionItem> collectionItems = new List<CollectionItem>();
 
@@ -35,11 +37,24 @@ namespace gaseous_server.Classes
             return collectionItems;
         }
 
-        public static CollectionItem GetCollection(long Id) {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql = "SELECT * FROM RomCollections WHERE Id = @id ORDER BY `Name`";
-			Dictionary<string, object> dbDict = new Dictionary<string, object>();
-			dbDict.Add("id", Id);
+        public static CollectionItem GetCollection(long Id, string userid) {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql;
+            if (userid == "")
+            {
+                // reserved for internal operations
+                sql = "SELECT * FROM RomCollections WHERE Id = @id ORDER BY `Name`";
+            }
+            else
+            {
+                // instigated by a user
+                sql = "SELECT * FROM RomCollections WHERE Id = @id AND OwnedBy = @ownedby ORDER BY `Name`";
+            }
+			Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "id", Id },
+                { "ownedby", userid }
+            };
 			DataTable romDT = db.ExecuteCMD(sql, dbDict);
 
 			if (romDT.Rows.Count > 0)
@@ -55,60 +70,68 @@ namespace gaseous_server.Classes
 			}
         }
 
-        public static CollectionItem NewCollection(CollectionItem item)
+        public static CollectionItem NewCollection(CollectionItem item, string userid)
         {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "INSERT INTO RomCollections (`Name`, Description, Platforms, Genres, Players, PlayerPerspectives, Themes, MinimumRating, MaximumRating, MaximumRomsPerPlatform, MaximumBytesPerPlatform, MaximumCollectionSizeInBytes, FolderStructure, IncludeBIOSFiles, AlwaysInclude, BuiltStatus) VALUES (@name, @description, @platforms, @genres, @players, @playerperspectives, @themes, @minimumrating, @maximumrating, @maximumromsperplatform, @maximumbytesperplatform, @maximumcollectionsizeinbytes, @folderstructure, @includebiosfiles, @alwaysinclude, @builtstatus); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("name", item.Name);
-            dbDict.Add("description", item.Description);
-            dbDict.Add("platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())));
-            dbDict.Add("genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())));
-            dbDict.Add("players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())));
-            dbDict.Add("playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())));
-            dbDict.Add("themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())));
-            dbDict.Add("minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1));
-            dbDict.Add("maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1));
-            dbDict.Add("maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1));
-            dbDict.Add("maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1));
-            dbDict.Add("maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1));
-            dbDict.Add("folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous));
-            dbDict.Add("includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0));
-            dbDict.Add("alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())));
-            dbDict.Add("builtstatus", CollectionItem.CollectionBuildStatus.WaitingForBuild);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "INSERT INTO RomCollections (`Name`, Description, Platforms, Genres, Players, PlayerPerspectives, Themes, MinimumRating, MaximumRating, MaximumRomsPerPlatform, MaximumBytesPerPlatform, MaximumCollectionSizeInBytes, FolderStructure, IncludeBIOSFiles, ArchiveType, AlwaysInclude, BuiltStatus, OwnedBy) VALUES (@name, @description, @platforms, @genres, @players, @playerperspectives, @themes, @minimumrating, @maximumrating, @maximumromsperplatform, @maximumbytesperplatform, @maximumcollectionsizeinbytes, @folderstructure, @includebiosfiles, @archivetype, @alwaysinclude, @builtstatus, @ownedby); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "name", item.Name },
+                { "description", item.Description },
+                { "platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())) },
+                { "genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())) },
+                { "players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())) },
+                { "playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())) },
+                { "themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())) },
+                { "minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1) },
+                { "maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1) },
+                { "maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1) },
+                { "maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1) },
+                { "maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1) },
+                { "folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous) },
+                { "includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0) },
+                { "archivetype", Common.ReturnValueIfNull(item.ArchiveType, CollectionItem.ArchiveTypes.Zip) },
+                { "alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())) },
+                { "builtstatus", CollectionItem.CollectionBuildStatus.WaitingForBuild },
+                { "ownedby", userid }
+            };
             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 gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "UPDATE RomCollections SET `Name`=@name, Description=@description, Platforms=@platforms, Genres=@genres, Players=@players, PlayerPerspectives=@playerperspectives, Themes=@themes, MinimumRating=@minimumrating, MaximumRating=@maximumrating, MaximumRomsPerPlatform=@maximumromsperplatform, MaximumBytesPerPlatform=@maximumbytesperplatform, MaximumCollectionSizeInBytes=@maximumcollectionsizeinbytes, FolderStructure=@folderstructure, IncludeBIOSFiles=@includebiosfiles, AlwaysInclude=@alwaysinclude, BuiltStatus=@builtstatus WHERE Id=@id";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("id", Id);
-            dbDict.Add("name", item.Name);
-            dbDict.Add("description", item.Description);
-            dbDict.Add("platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())));
-            dbDict.Add("genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())));
-            dbDict.Add("players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())));
-            dbDict.Add("playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())));
-            dbDict.Add("themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())));
-            dbDict.Add("minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1));
-            dbDict.Add("maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1));
-            dbDict.Add("maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1));
-            dbDict.Add("maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1));
-            dbDict.Add("maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1));
-            dbDict.Add("folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous));
-            dbDict.Add("includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0));
-            dbDict.Add("alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())));
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "UPDATE RomCollections SET `Name`=@name, Description=@description, Platforms=@platforms, Genres=@genres, Players=@players, PlayerPerspectives=@playerperspectives, Themes=@themes, MinimumRating=@minimumrating, MaximumRating=@maximumrating, MaximumRomsPerPlatform=@maximumromsperplatform, MaximumBytesPerPlatform=@maximumbytesperplatform, MaximumCollectionSizeInBytes=@maximumcollectionsizeinbytes, FolderStructure=@folderstructure, IncludeBIOSFiles=@includebiosfiles, ArchiveType=@archivetype, AlwaysInclude=@alwaysinclude, BuiltStatus=@builtstatus WHERE Id=@id AND OwnedBy=@ownedby";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "id", Id },
+                { "name", item.Name },
+                { "description", item.Description },
+                { "platforms", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Platforms, new List<long>())) },
+                { "genres", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Genres, new List<long>())) },
+                { "players", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Players, new List<long>())) },
+                { "playerperspectives", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.PlayerPerspectives, new List<long>())) },
+                { "themes", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.Themes, new List<long>())) },
+                { "minimumrating", Common.ReturnValueIfNull(item.MinimumRating, -1) },
+                { "maximumrating", Common.ReturnValueIfNull(item.MaximumRating, -1) },
+                { "maximumromsperplatform", Common.ReturnValueIfNull(item.MaximumRomsPerPlatform, -1) },
+                { "maximumbytesperplatform", Common.ReturnValueIfNull(item.MaximumBytesPerPlatform, -1) },
+                { "maximumcollectionsizeinbytes", Common.ReturnValueIfNull(item.MaximumCollectionSizeInBytes, -1) },
+                { "folderstructure", Common.ReturnValueIfNull(item.FolderStructure, CollectionItem.FolderStructures.Gaseous) },
+                { "includebiosfiles", Common.ReturnValueIfNull(item.IncludeBIOSFiles, 0) },
+                { "alwaysinclude", Newtonsoft.Json.JsonConvert.SerializeObject(Common.ReturnValueIfNull(item.AlwaysInclude, new List<CollectionItem.AlwaysIncludeItem>())) },
+                { "archivetype", Common.ReturnValueIfNull(item.ArchiveType, CollectionItem.ArchiveTypes.Zip) },
+                { "ownedby", userid }
+            };
             
-            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);
@@ -131,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 gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string sql = "DELETE FROM RomCollections WHERE Id=@id";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("id", Id);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM RomCollections WHERE Id=@id AND OwnedBy=@ownedby";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "id", Id },
+                { "ownedby", userid }
+            };
             db.ExecuteCMD(sql, dbDict);
 
             string CollectionZipFile = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, Id + ".zip");
@@ -156,14 +182,15 @@ 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)
             {
                 // set collection item to waitingforbuild
-                Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
                 string sql = "UPDATE RomCollections SET BuiltStatus=@bs WHERE Id=@id";
                 Dictionary<string, object> dbDict = new Dictionary<string, object>();
                 dbDict.Add("id", Id);
@@ -172,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
@@ -212,9 +266,16 @@ namespace gaseous_server.Classes
                 }
             } else {
                 // get all platforms to pull from
-                FilterController filterController = new FilterController();
-                platforms.AddRange((List<Platform>)filterController.Filter()["platforms"]);
+                Dictionary<string, List<Filters.FilterItem>> FilterDict = Filters.Filter(AgeGroups.AgeRestrictionGroupings.Adult, true);
+                List<Classes.Filters.FilterItem> filteredPlatforms = (List<Classes.Filters.FilterItem>)FilterDict["platforms"];
+                foreach (Filters.FilterItem filterItem in filteredPlatforms) {
+                    platforms.Add(Platforms.GetPlatform(filterItem.Id));
                 }
+            }
+
+            // age ratings
+            AgeGroups.AgeRestrictionGroupings AgeGrouping = AgeGroups.AgeRestrictionGroupings.Unclassified;
+            bool ContainsUnclassifiedAgeGroup = false;
 
             // build collection
             List<CollectionContents.CollectionPlatformItem> platformItems = new List<CollectionContents.CollectionPlatformItem>();
@@ -233,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("",
-                        platform.Id.ToString(),
-                        string.Join(",", collectionItem.Genres),
-                        string.Join(",", collectionItem.Players),
-                        string.Join(",", collectionItem.PlayerPerspectives),
-                        string.Join(",", collectionItem.Themes),
-                        collectionItem.MinimumRating,
-                        collectionItem.MaximumRating
-                    );
+                    Controllers.v1_1.GamesController.GameSearchModel searchModel = new Controllers.v1_1.GamesController.GameSearchModel{
+                        Name = "",
+                        Platform = new List<string>{
+                            platform.Id.ToString()
+                        },
+                        Genre = collectionItem.Genres.ConvertAll(s => s.ToString()),
+                        GameMode = collectionItem.Players.ConvertAll(s => s.ToString()),
+                        PlayerPerspective = collectionItem.PlayerPerspectives.ConvertAll(s => s.ToString()),
+                        Theme = collectionItem.Themes.ConvertAll(s => s.ToString()),
+                        GameRating = new Controllers.v1_1.GamesController.GameSearchModel.GameRatingItem{
+                            MinimumRating = collectionItem.MinimumRating,
+                            MaximumRating = collectionItem.MaximumRating
+                        },
+                        GameAgeRating = new Controllers.v1_1.GamesController.GameSearchModel.GameAgeRatingItem{
+                            AgeGroupings = UserAgeGroupings,
+                            IncludeUnrated = UserAgeGroupIncludeUnrated
+                        }
+                    };
+                    games = Controllers.v1_1.GamesController.GetGames(searchModel, userid);
+                    
                 }
 
                 CollectionContents.CollectionPlatformItem collectionPlatformItem = new CollectionContents.CollectionPlatformItem(platform);
@@ -260,19 +332,19 @@ 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;
                             gameItem.InclusionStatus.GameId = alwaysIncludeItem.GameId;
                             gameItem.InclusionStatus.InclusionState = alwaysIncludeItem.InclusionState;
-                            gameItem.Roms = Roms.GetRoms((long)gameItem.Id, (long)platform.Id);
+                            gameItem.Roms = Roms.GetRoms((long)gameItem.Id, (long)platform.Id).GameRomItems;
 
                             collectionPlatformItem.Games.Add(gameItem);
                     }
                 }
 
-                foreach (Game game in games) {
+                foreach (MinimalGameItem game in games.Games) {
                     bool gameAlreadyInList = false;
                     foreach (CollectionContents.CollectionPlatformItem.CollectionGameItem existingGame in collectionPlatformItem.Games) 
                     {
@@ -286,14 +358,14 @@ namespace gaseous_server.Classes
                     {
                         CollectionContents.CollectionPlatformItem.CollectionGameItem collectionGameItem = new CollectionContents.CollectionPlatformItem.CollectionGameItem(game);
 
-                        List<Roms.GameRomItem> gameRoms = Roms.GetRoms((long)game.Id, (long)platform.Id);
+                        List<Roms.GameRomItem> gameRoms = Roms.GetRoms((long)game.Id, (long)platform.Id).GameRomItems;
                         
                         bool AddGame = false;
 
                         // 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) {
@@ -327,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));
@@ -355,30 +438,40 @@ namespace gaseous_server.Classes
 
             collectionPlatformItems.Sort((x, y) => x.Name.CompareTo(y.Name));
 
-            CollectionContents collectionContents = new CollectionContents();
-            collectionContents.Collection = collectionPlatformItems;
+            CollectionContents collectionContents = new CollectionContents
+            {
+                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 gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            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";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("id", collectionItem.Id);
-                dbDict.Add("bs", CollectionItem.CollectionBuildStatus.Building);
+                string sql = "UPDATE RomCollections SET BuiltStatus=@bs, AgeGroup=@ag, AgeGroupUnclassified=@agu WHERE Id=@id";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>
+                {
+                    { "id", collectionItem.Id },
+                    { "bs", CollectionItem.CollectionBuildStatus.Building },
+                    { "ag", collectionContents.AgeGroup },
+                    { "agu", collectionContents.ContainsUnclassifiedAgeGroup }
+                };
                 db.ExecuteCMD(sql, dbDict);
                 
-                List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = GetCollectionContent(collectionItem).Collection;
-                string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, collectionItem.Id + ".zip");
+                List<CollectionContents.CollectionPlatformItem> collectionPlatformItems = collectionContents.Collection;
+                string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryCollectionsDirectory, collectionItem.Id + collectionItem.ArchiveExtension);
                 string ZipFileTempPath = Path.Combine(Config.LibraryConfiguration.LibraryTempDirectory, collectionItem.Id.ToString());
 
                 try
@@ -416,7 +509,7 @@ namespace gaseous_server.Classes
                                 if (File.Exists(biosItem.biosPath))
                                 {
                                     Logging.Log(Logging.LogType.Information, "Collections", "Copying BIOS file: " + biosItem.filename);
-                                    File.Copy(biosItem.biosPath, Path.Combine(ZipBiosPath, biosItem.filename));
+                                    File.Copy(biosItem.biosPath, Path.Combine(ZipBiosPath, biosItem.filename), true);
                                 }
                             }
                         }
@@ -488,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);
                                     }
                                 }
                             }
@@ -497,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))
@@ -556,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);
 
@@ -584,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]
@@ -593,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;
                         }
@@ -621,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);
@@ -654,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; }
@@ -696,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" };
@@ -738,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;
                             }
                         }
 
@@ -746,41 +890,45 @@ namespace gaseous_server.Classes
                     }
                 }
 
-                public class CollectionGameItem {
-                    public CollectionGameItem(IGDB.Models.Game game) {
-                        string[] PropertyWhitelist = new string[] { "Id", "Name", "Slug", "Cover" };
-                        PropertyInfo[] srcProperties = typeof(IGDB.Models.Game).GetProperties();
-                        PropertyInfo[] dstProperties = typeof(CollectionPlatformItem.CollectionGameItem).GetProperties();
-                        foreach (PropertyInfo srcProperty in srcProperties) {
-                            if (PropertyWhitelist.Contains<string>(srcProperty.Name))
+                public class CollectionGameItem : MinimalGameItem
                 {
-                                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) {
-                                            string compareName = srcProperty.PropertyType.Name.ToLower().Split("`")[0];
-                                            switch(compareName) {
-                                                case "identityorvalue":
-                                                    string newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(srcProperty.GetValue(game));
-                                                    Dictionary<string, object> newDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(newObjectValue);
-                                                    dstProperty.SetValue(this, newDict["Id"]);
-                                                    break;
-                                                default:
-                                                    dstProperty.SetValue(this, srcProperty.GetValue(game));
-                                                    break;
-                                            }
-                                        }
-                                    }
+                        get
+                        {
+                            if (Cover != null)
+                            {
+                                IGDB.Models.Cover cover = Covers.GetCover(Cover.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory, "Games", Slug), false);
+
+                                return cover;
                             }
+                            else
+                            {
+                                return null;
                             }
                         }
                     }
 
-                    public long Id { get; set; }
-                    public string Name { get; set; }
-                    public string Slug { get; set; }
-                    public long Cover { get; set;}
+                    public AgeGroups.AgeRestrictionGroupings AgeGrouping
+                    { 
+                        get
+                        {
+                            return AgeGroups.GetAgeGroupFromAgeRatings(this.AgeRatings);
+                        }
+                    }
 
                     public CollectionItem.AlwaysIncludeItem InclusionStatus { get; set; }
 
@@ -790,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,12 @@
-using System;
+using System.Collections.Concurrent;
+using System.ComponentModel;
+using System.IO.Compression;
+using System.Reflection;
 using System.Security.Cryptography;
 
-namespace gaseous_tools
+namespace gaseous_server.Classes
 {
-	public class Common
+	public static class Common
 	{
 		/// <summary>
 		/// Returns IfNullValue if the ObjectToCheck is null
@@ -110,6 +113,72 @@ namespace gaseous_tools
 			return Path.GetFullPath(new Uri(path).LocalPath)
 					.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
 		}
+
+		public static string GetDescription(this Enum value)
+		{
+			return ((DescriptionAttribute)Attribute.GetCustomAttribute(
+				value.GetType().GetFields(BindingFlags.Public | BindingFlags.Static)
+					.Single(x => x.GetValue(null).Equals(value)),
+				typeof(DescriptionAttribute)))?.Description ?? value.ToString();
+		}
+
+		// compression
+		public static byte[] Compress(byte[] data)
+		{
+			MemoryStream output = new MemoryStream();
+			using (DeflateStream dstream = new DeflateStream(output, CompressionLevel.Optimal))
+			{
+				dstream.Write(data, 0, data.Length);
+			}
+			return output.ToArray();
+		}
+
+		public static byte[] Decompress(byte[] data)
+		{
+			MemoryStream input = new MemoryStream(data);
+			MemoryStream output = new MemoryStream();
+			using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
+			{
+				dstream.CopyTo(output);
+			}
+			return output.ToArray();
+		}
+
+		public static object GetEnvVar(string envName, string defaultValue)
+		{
+			if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable(envName)))
+			{
+				return Environment.GetEnvironmentVariable(envName);
+			}
+			else
+			{
+				return defaultValue;
+			}
 		}
     }
 
+	/// <summary>
+    /// Provides a way to set contextual data that flows with the call and 
+    /// async context of a test or invocation.
+    /// </summary>
+    public static class CallContext
+    {
+        static ConcurrentDictionary<string, AsyncLocal<object>> state = new ConcurrentDictionary<string, AsyncLocal<object>>();
+
+        /// <summary>
+        /// Stores a given object and associates it with the specified name.
+        /// </summary>
+        /// <param name="name">The name with which to associate the new item in the call context.</param>
+        /// <param name="data">The object to store in the call context.</param>
+        public static void SetData(string name, object data) =>
+            state.GetOrAdd(name, _ => new AsyncLocal<object>()).Value = data;
+
+        /// <summary>
+        /// Retrieves an object with the specified name from the <see cref="CallContext"/>.
+        /// </summary>
+        /// <param name="name">The name of the item in the call context.</param>
+        /// <returns>The object in the call context associated with the specified name, or <see langword="null"/> if not found.</returns>
+        public static object GetData(string name) =>
+            state.TryGetValue(name, out AsyncLocal<object> data) ? data.Value : null;
+    }
+}

gaseous-server/Classes/Config.cs

@@ -1,10 +1,11 @@
 using System;
 using System.Data;
-using Google.Protobuf.WellKnownTypes;
 using Newtonsoft.Json;
 using IGDB.Models;
+using gaseous_server.Classes.Metadata;
+using NuGet.Common;
 
-namespace gaseous_tools
+namespace gaseous_server.Classes
 {
     public static class Config
     {
@@ -58,6 +59,14 @@ namespace gaseous_tools
             }
         }
 
+        public static ConfigFile.MetadataAPI MetadataConfiguration
+        {
+            get
+            {
+                return _config.MetadataConfiguration;
+            }
+        }
+
         public static ConfigFile.IGDB IGDB
         {
             get
@@ -109,11 +118,33 @@ namespace gaseous_tools
                     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
@@ -153,7 +184,7 @@ namespace gaseous_tools
             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()
         {
@@ -163,45 +194,91 @@ namespace gaseous_tools
             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);
                 }
-                else
+                
+                Logging.Log(Logging.LogType.Information, "Load Settings", "Loading setting " + SettingName + " from database");
+                
+                try
                 {
-                    AppSettings.Add((string)dataRow["Setting"], (string)dataRow["Value"]);
+                    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;
+                    }
+                }
+                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 = "SELECT Value FROM Settings WHERE Setting = @SettingName";
-                Dictionary<string, object> dbDict = new Dictionary<string, object>();
-                dbDict.Add("SettingName", SettingName);
-                dbDict.Add("Value", DefaultValue);
+                    
+                    string sql = "SELECT Value, ValueDate FROM Settings WHERE Setting = @SettingName";
+                    Dictionary<string, object> dbDict = new Dictionary<string, object>
+                    {
+                        { "SettingName", SettingName }
+                    };
 
                     try
                     {
                         Logging.Log(Logging.LogType.Debug, "Database", "Reading setting '" + SettingName + "'");
                         DataTable 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]);
-                        return (string)dbResponse.Rows[0][0];
+                            if (type.ToString() == "System.DateTime")
+                            {
+                                AppSettings.Add(SettingName, dbResponse.Rows[0]["ValueDate"]);
+                                return (T)dbResponse.Rows[0]["ValueDate"];
+                            }
+                            else
+                            {
+                                AppSettings.Add(SettingName, dbResponse.Rows[0]["Value"]);
+                                return (T)dbResponse.Rows[0]["Value"];
+                            }
                         }
                     }
                     catch (Exception ex)
@@ -211,14 +288,58 @@ namespace gaseous_tools
                     }
                 }
             }
+            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)";
-            Dictionary<string, object> dbDict = new Dictionary<string, object>();
-            dbDict.Add("SettingName", SettingName);
-            dbDict.Add("Value", Value);
+            string sql = "REPLACE INTO Settings (Setting, ValueType, Value, ValueDate) VALUES (@SettingName, @ValueType, @Value, @ValueDate)";
+            Dictionary<string, object> dbDict;
+            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 }
+                };
+            }
 
             Logging.Log(Logging.LogType.Debug, "Database", "Storing setting '" + SettingName + "' to value: '" + Value + "'");
             try
@@ -248,6 +369,8 @@ namespace gaseous_tools
             [JsonIgnore]
             public Library LibraryConfiguration = new Library();
 
+            public MetadataAPI MetadataConfiguration = new MetadataAPI();
+
             public IGDB IGDBConfiguration = new IGDB();
 
             public Logging LoggingConfiguration = new Logging();
@@ -298,11 +421,41 @@ namespace gaseous_tools
                     }
                 }
 
+                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 int Port = 3306;
+                public string DatabaseName = _DefaultDatabaseName;
+                public int Port = _DefaultDatabasePort;
 
                 [JsonIgnore]
                 public string ConnectionString
@@ -313,6 +466,16 @@ namespace gaseous_tools
                         return dbConnString;
                     }
                 }
+
+                [JsonIgnore]
+                public string ConnectionStringNoDatabase
+                {
+                    get
+                    {
+                        string dbConnString = "server=" + HostName + ";port=" + Port + ";userid=" + UserName + ";password=" + Password + ";";
+                        return dbConnString;
+                    }
+                }
             }
 
             public class Library
@@ -321,11 +484,11 @@ namespace gaseous_tools
                 {
                     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);
                     }
                 }
 
@@ -337,13 +500,29 @@ namespace gaseous_tools
                     }
                 }
 
-                // public string LibraryDataDirectory
-                // {
-                //     get
-                //     {
-                //         return Path.Combine(LibraryRootDirectory, "Library");
-                //     }
-                // }
+                public string LibraryImportErrorDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryRootDirectory, "Import Errors");
+                    }
+                }
+
+                public string LibraryImportDuplicatesDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryImportErrorDirectory, "Duplicates");
+                    }
+                }
+
+                public string LibraryImportGeneralErrorDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryImportErrorDirectory, "Error");
+                    }
+                }
 
                 public string LibraryBIOSDirectory
                 {
@@ -385,6 +564,14 @@ namespace gaseous_tools
                     }
                 }
 
+                public string LibraryMediaGroupDirectory
+                {
+                    get
+                    {
+                        return Path.Combine(LibraryRootDirectory, "Media Groups");
+                    }
+                }
+
                 public string LibraryMetadataDirectory_Platform(Platform platform)
                 {
                     string MetadataPath = Path.Combine(LibraryMetadataDirectory, "Platforms", platform.Slug);
@@ -427,6 +614,77 @@ namespace gaseous_tools
                 }
             }
 
+            public class MetadataAPI
+            {
+                private static HasheousClient.Models.MetadataModel.MetadataSources _MetadataSource
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("metadatasource")))
+                        {
+                            return (HasheousClient.Models.MetadataModel.MetadataSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.MetadataSources), Environment.GetEnvironmentVariable("metadatasource"));
+                        }
+                        else
+                        {
+                            return HasheousClient.Models.MetadataModel.MetadataSources.IGDB;
+                        }
+                    }
+                }
+
+                private static HasheousClient.Models.MetadataModel.SignatureSources _SignatureSource
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("signaturesource")))
+                        {
+                            return (HasheousClient.Models.MetadataModel.SignatureSources)Enum.Parse(typeof(HasheousClient.Models.MetadataModel.SignatureSources), Environment.GetEnvironmentVariable("signaturesource"));
+                        }
+                        else
+                        {
+                            return HasheousClient.Models.MetadataModel.SignatureSources.LocalOnly;
+                        }
+                    }
+                }
+
+                private static int _MaxLibraryScanWorkers
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("maxlibraryscanworkers")))
+                        {
+                            return int.Parse(Environment.GetEnvironmentVariable("maxlibraryscanworkers"));
+                        }
+                        else
+                        {
+                            return 4;
+                        }
+                    }
+                }
+
+                private static string _HasheousHost
+                {
+                    get
+                    {
+                        if (!String.IsNullOrEmpty(Environment.GetEnvironmentVariable("hasheoushost")))
+                        {
+                            return Environment.GetEnvironmentVariable("hasheoushost");
+                        }
+                        else
+                        {
+                            return "https://hasheous.org/";
+                        }
+                    }
+                }
+
+                public HasheousClient.Models.MetadataModel.MetadataSources MetadataSource = _MetadataSource;
+
+                public HasheousClient.Models.MetadataModel.SignatureSources SignatureSource = _SignatureSource;
+
+                public int MaxLibraryScanWorkers = _MaxLibraryScanWorkers;
+
+                public string HasheousHost = _HasheousHost;
+            }
+
             public class IGDB
             {
                 private static string _DefaultIGDBClientId
@@ -470,11 +728,7 @@ namespace gaseous_tools
                 // log retention in days
                 public int LogRetention = 7;
 
-                public enum LoggingFormat
-                {
-                    Json,
-                    Text
-                }
+                public bool AlwaysLogToDisk = false;
             }
         }
     }

gaseous-server/Classes/Database.cs

@@ -3,10 +3,9 @@ using System.Data;
 using System.Data.SqlClient;
 using System.Diagnostics;
 using System.Reflection;
-using MySql.Data.MySqlClient;
-using static gaseous_tools.Database;
+using MySqlConnector;
 
-namespace gaseous_tools
+namespace gaseous_server.Classes
 {
 	public class Database
 	{
@@ -69,7 +68,7 @@ namespace gaseous_tools
 					ExecuteCMD(sql, dbDict, 30, "server=" + Config.DatabaseConfiguration.HostName + ";port=" + Config.DatabaseConfiguration.Port + ";userid=" + Config.DatabaseConfiguration.UserName + ";password=" + Config.DatabaseConfiguration.Password);
 
 					// check if schema version table is in place - if not, create the schema version table
-					sql = "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = 'gaseous' AND TABLE_NAME = 'schema_version';";
+					sql = "SELECT TABLE_SCHEMA, TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = '" + Config.DatabaseConfiguration.DatabaseName + "' AND TABLE_NAME = 'schema_version';";
 					DataTable SchemaVersionPresent = ExecuteCMD(sql, dbDict);
 					if (SchemaVersionPresent.Rows.Count == 0)
 					{
@@ -81,7 +80,7 @@ namespace gaseous_tools
 
                     for (int i = 1000; i < 10000; i++)
 					{
-						string resourceName = "gaseous_tools.Database.MySQL.gaseous-" + i + ".sql";
+						string resourceName = "gaseous_server.Support.Database.MySQL.gaseous-" + i + ".sql";
 						string dbScript = "";
 
 						string[] resources = Assembly.GetExecutingAssembly().GetManifestResourceNames();
@@ -107,13 +106,15 @@ namespace gaseous_tools
 									int SchemaVer = (int)SchemaVersion.Rows[0][0];
                                     Logging.Log(Logging.LogType.Information, "Database", "Schema version is " + SchemaVer);
                                     if (SchemaVer < i)
+									{
+										try
 										{
 											// run pre-upgrade code
-										gaseous_tools.DatabaseMigration.PreUpgradeScript(i, _ConnectorType);
+											DatabaseMigration.PreUpgradeScript(i, _ConnectorType);
 											
 											// apply schema!
 											Logging.Log(Logging.LogType.Information, "Database", "Updating schema to version " + i);
-                                        ExecuteCMD(dbScript, dbDict);
+											ExecuteCMD(dbScript, dbDict, 180);
 
 											sql = "UPDATE schema_version SET schema_version=@schemaver";
 											dbDict = new Dictionary<string, object>();
@@ -121,7 +122,13 @@ namespace gaseous_tools
 											ExecuteCMD(sql, dbDict);
 
 											// run post-upgrade code
-										gaseous_tools.DatabaseMigration.PostUpgradeScript(i, _ConnectorType);
+											DatabaseMigration.PostUpgradeScript(i, _ConnectorType);
+										}
+										catch (Exception ex)
+										{
+											Logging.Log(Logging.LogType.Critical, "Database", "Schema upgrade failed! Unable to continue.", ex);
+											System.Environment.Exit(1);
+										}
 									}
 								}
 							}
@@ -148,6 +155,50 @@ namespace gaseous_tools
 			return _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
         }
 
+		public List<Dictionary<string, object>> ExecuteCMDDict(string Command)
+		{
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			return _ExecuteCMDDict(Command, dbDict, 30, "");
+		}
+
+        public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters)
+        {
+            return _ExecuteCMDDict(Command, Parameters, 30, "");
+        }
+
+        public List<Dictionary<string, object>> ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+        {
+			return _ExecuteCMDDict(Command, Parameters, Timeout, ConnectionString);
+        }
+
+		private List<Dictionary<string, object>> _ExecuteCMDDict(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+		{
+			DataTable dataTable = _ExecuteCMD(Command, Parameters, Timeout, ConnectionString);
+
+			// convert datatable to dictionary
+			List<Dictionary<string, object?>> rows = new List<Dictionary<string, object?>>();
+
+			foreach (DataRow dataRow in dataTable.Rows)
+			{
+				Dictionary<string, object?> row = new Dictionary<string, object?>();
+				for (int i = 0; i < dataRow.Table.Columns.Count; i++)
+				{
+					string columnName = dataRow.Table.Columns[i].ColumnName;
+					if (dataRow[i] == System.DBNull.Value)
+					{
+						row.Add(columnName, null);
+					}
+					else
+					{
+						row.Add(columnName, dataRow[i].ToString());
+					}
+				}
+				rows.Add(row);
+			}
+
+			return rows;
+		}
+
         private DataTable _ExecuteCMD(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
         {
             if (ConnectionString == "") { ConnectionString = _ConnectionString; }
@@ -161,6 +212,36 @@ namespace gaseous_tools
             }
         }
 
+		public int ExecuteNonQuery(string Command)
+		{
+			Dictionary<string, object> dbDict = new Dictionary<string, object>();
+			return _ExecuteNonQuery(Command, dbDict, 30, "");
+		}
+
+        public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters)
+        {
+            return _ExecuteNonQuery(Command, Parameters, 30, "");
+        }
+
+        public int ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+        {
+			return _ExecuteNonQuery(Command, Parameters, Timeout, ConnectionString);
+        }
+
+        private int _ExecuteNonQuery(string Command, Dictionary<string, object> Parameters, int Timeout = 30, string ConnectionString = "")
+        {
+            if (ConnectionString == "") { ConnectionString = _ConnectionString; }
+            switch (_ConnectorType)
+            {
+                case databaseType.MySql:
+                    MySQLServerConnector conn = new MySQLServerConnector(ConnectionString);
+					int retVal = conn.ExecNonQuery(Command, Parameters, Timeout); 
+                    return retVal;
+                default:
+                    return 0;
+            }
+        }
+
         public void ExecuteTransactionCMD(List<SQLTransactionItem> CommandList, int Timeout = 60)
         {
             object conn;
@@ -249,7 +330,8 @@ namespace gaseous_tools
 				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
@@ -281,13 +363,58 @@ namespace gaseous_tools
 
 					Logging.Log(Logging.LogType.Debug, "Database", "Closing database connection", null, true);
 					conn.Close();
+				}
 
 				return RetTable;
 			}
 
+			public int ExecNonQuery(string SQL, Dictionary< string, object> Parameters, int Timeout)
+			{
+				int result = 0;
+
+                Logging.Log(Logging.LogType.Debug, "Database", "Connecting to database", null, true);
+                using (MySqlConnection conn = new MySqlConnection(DBConn))
+				{
+					conn.Open();
+
+					MySqlCommand cmd = new MySqlCommand
+					{
+						Connection = conn,
+						CommandText = SQL,
+						CommandTimeout = Timeout
+					};
+
+					foreach (string Parameter in Parameters.Keys)
+					{
+						cmd.Parameters.AddWithValue(Parameter, Parameters[Parameter]);
+					}
+
+					try
+					{
+						Logging.Log(Logging.LogType.Debug, "Database", "Executing sql: '" + SQL + "'", null, true);
+						if (Parameters.Count > 0)
+						{
+							string dictValues = string.Join(";", Parameters.Select(x => string.Join("=", x.Key, x.Value)));
+							Logging.Log(Logging.LogType.Debug, "Database", "Parameters: " + dictValues, null, true);
+						}
+						result = cmd.ExecuteNonQuery();
+					} catch (Exception ex) {
+						Logging.Log(Logging.LogType.Critical, "Database", "Error while executing '" + SQL + "'", ex);
+						Trace.WriteLine("Error executing " + SQL);
+						Trace.WriteLine("Full exception: " + ex.ToString());
+					}
+
+					Logging.Log(Logging.LogType.Debug, "Database", "Closing database connection", null, true);
+					conn.Close();
+				}
+
+				return result;
+			}
+
             public void TransactionExecCMD(List<Dictionary<string, object>> Parameters, int Timeout)
             {
-                var conn = new MySqlConnection(DBConn);
+                using (MySqlConnection conn = new MySqlConnection(DBConn))
+                {
 					conn.Open();
 					var command = conn.CreateCommand();
 					MySqlTransaction transaction;
@@ -304,6 +431,7 @@ namespace gaseous_tools
 					transaction.Commit();
 					conn.Close();
 				}
+            }
 
             private MySqlCommand buildcommand(MySqlConnection Conn, string SQL, Dictionary<string, object> Parameters, int Timeout)
             {
@@ -328,7 +456,8 @@ namespace gaseous_tools
 
 			public bool TestConnection()
 			{
-				MySqlConnection conn = new MySqlConnection(DBConn);
+				using (MySqlConnection conn = new MySqlConnection(DBConn))
+				{
 					try
 					{
 						conn.Open();
@@ -343,4 +472,5 @@ namespace gaseous_tools
 			}
         }
     }
+}
 

gaseous-server/Classes/DatabaseMigration.cs

@@ -1,21 +1,73 @@
 using System;
 using System.Data;
+using System.Reflection;
 
-namespace gaseous_tools
+namespace gaseous_server.Classes
 {
 	public static class DatabaseMigration
 	{
         public static List<int> BackgroundUpgradeTargetSchemaVersions = new List<int>();
 
-        public static void PreUpgradeScript(int TargetSchemaVersion, gaseous_tools.Database.databaseType? DatabaseType) 
+        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, gaseous_tools.Database.databaseType? DatabaseType) 
+        public static void PostUpgradeScript(int TargetSchemaVersion, Database.databaseType? DatabaseType) 
         {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            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 +84,12 @@ namespace gaseous_tools
 
                             // 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 +98,11 @@ namespace gaseous_tools
                             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;
                     }
                     break;
             }
@@ -65,7 +122,7 @@ namespace gaseous_tools
         }
 
         public static void MySql_1002_MigrateMetadataVersion() {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
 

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

gaseous-server/Classes/Filters.cs

@@ -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);
+
+            foreach (DataRow dr in dbResponse.Rows)
+            {
+                FilterItem platformItem = new FilterItem(dr);
+                platforms.Add(platformItem);
+
+            }
+            FilterSet.Add("platforms", platforms);
+
+            // genres
+            List<FilterItem> genres = new List<FilterItem>();
+            dbResponse = GetGenericFilterItem(db, "Genre", ageRestriction_Platform);
+
+            foreach (DataRow dr in dbResponse.Rows)
+            {
+                FilterItem genreItem = new FilterItem(dr);
+                genres.Add(genreItem);
+            }
+            FilterSet.Add("genres", genres);
+
+            // game modes
+            List<FilterItem> gameModes = new List<FilterItem>();
+            dbResponse = GetGenericFilterItem(db, "GameMode", ageRestriction_Platform);
+
+            foreach (DataRow dr in dbResponse.Rows)
+            {
+                FilterItem gameModeItem = new FilterItem(dr);
+                gameModes.Add(gameModeItem);
+            }
+            FilterSet.Add("gamemodes", gameModes);
+
+            // player perspectives
+            List<FilterItem> playerPerspectives = new List<FilterItem>();
+            dbResponse = GetGenericFilterItem(db, "PlayerPerspective", ageRestriction_Platform);
+
+            foreach (DataRow dr in dbResponse.Rows)
+            {
+                FilterItem playerPerspectiveItem = new FilterItem(dr);
+                playerPerspectives.Add(playerPerspectiveItem);
+            }
+            FilterSet.Add("playerperspectives", playerPerspectives);
+
+            // themes
+            List<FilterItem> themes = new List<FilterItem>();
+            dbResponse = GetGenericFilterItem(db, "Theme", ageRestriction_Platform);
+
+            foreach (DataRow dr in dbResponse.Rows)
+            {
+                FilterItem themeItem = new FilterItem(dr);
+                themes.Add(themeItem);
+            }
+            FilterSet.Add("themes", themes);
+
+            // age groups
+            List<FilterItem> agegroupings = new List<FilterItem>();
+            sql = "SELECT Game.AgeGroupId, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, AgeGroup.AgeGroupId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + ageRestriction_Platform + ") GROUP BY Game.Id HAVING RomCount > 0) Game GROUP BY Game.AgeGroupId ORDER BY Game.AgeGroupId DESC";
+            dbResponse = db.ExecuteCMD(sql);
+
+            foreach (DataRow dr in dbResponse.Rows)
+            {
+                FilterItem filterAgeGrouping = new FilterItem();
+                if (dr["AgeGroupId"] == DBNull.Value)
+                {
+                    filterAgeGrouping.Id = (int)(long)AgeGroups.AgeRestrictionGroupings.Unclassified;
+                    filterAgeGrouping.Name = AgeGroups.AgeRestrictionGroupings.Unclassified.ToString();
+                }
+                else
+                {
+                    int ageGroupLong = (int)dr["AgeGroupId"];
+                    AgeGroups.AgeRestrictionGroupings ageGroup = (AgeGroups.AgeRestrictionGroupings)ageGroupLong;
+                    filterAgeGrouping.Id = ageGroupLong;
+                    filterAgeGrouping.Name = ageGroup.ToString();
+                }
+                filterAgeGrouping.GameCount = (int)(long)dr["GameCount"];
+                agegroupings.Add(filterAgeGrouping);
+            }
+            FilterSet.Add("agegroupings", agegroupings);
+
+            return FilterSet;
+        }
+
+        private static DataTable GetGenericFilterItem(Database db, string Name, string AgeRestriction)
+        {
+            //string sql = "SELECT DISTINCT <ITEMNAME>.Id, <ITEMNAME>.`Name`, COUNT(view_Games.Id) AS GameCount FROM <ITEMNAME> LEFT JOIN Relation_Game_<ITEMNAME>s ON Relation_Game_<ITEMNAME>s.<ITEMNAME>sId = <ITEMNAME>.Id LEFT JOIN view_Games ON view_Games.Id = Relation_Game_<ITEMNAME>s.GameId WHERE (" + AgeRestriction_Generic + ") GROUP BY <ITEMNAME>.Id HAVING GameCount > 0 ORDER BY <ITEMNAME>.`Name`;";
+
+            string sql = "SELECT <ITEMNAME>.Id, <ITEMNAME>.`Name`, COUNT(Game.Id) AS GameCount FROM (SELECT DISTINCT Game.Id, AgeGroup.AgeGroupId, COUNT(Games_Roms.Id) AS RomCount FROM Game LEFT JOIN AgeGroup ON Game.Id = AgeGroup.GameId LEFT JOIN Games_Roms ON Game.Id = Games_Roms.GameId WHERE (" + AgeRestriction + ") GROUP BY Game.Id HAVING RomCount > 0) Game JOIN Relation_Game_<ITEMNAME>s ON Game.Id = Relation_Game_<ITEMNAME>s.GameId JOIN <ITEMNAME> ON Relation_Game_<ITEMNAME>s.<ITEMNAME>sId = <ITEMNAME>.Id GROUP BY <ITEMNAME>.`Name` ORDER BY <ITEMNAME>.`Name`;";
+            sql = sql.Replace("<ITEMNAME>", Name);
+            DataTable dbResponse = db.ExecuteCMD(sql);
+
+            return dbResponse;
+        }
+
+        public class FilterItem
+        {
+            public FilterItem()
+            {
+
+            }
+
+            public FilterItem(DataRow dr)
+            {
+                this.Id = (long)dr["Id"];
+                this.Name = (string)dr["Name"];
+                this.GameCount = (int)(long)dr["GameCount"];
+            }
+
+            public long Id { get; set; }
+
+            public string Name { get; set; }
+
+            public int GameCount { get; set; }
+        }
+    }
+}

gaseous-server/Classes/GameLibrary.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Data;
+using gaseous_server.Classes;
 using gaseous_server.Classes.Metadata;
-using gaseous_tools;
 using IGDB.Models;
 using Microsoft.CodeAnalysis.FlowAnalysis.DataFlow;
 
@@ -34,17 +34,28 @@ 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
         {
             get
             {
-                Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
                 string sql = "SELECT * FROM GameLibraries WHERE DefaultLibrary=1 LIMIT 1";
                 DataTable data = db.ExecuteCMD(sql);
                 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;
             }
         }
@@ -54,13 +65,22 @@ namespace gaseous_server
             get
             {
                 List<LibraryItem> libraryItems = new List<LibraryItem>();
-                Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
                 string sql = "SELECT * FROM GameLibraries";
                 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;
@@ -86,7 +106,7 @@ namespace gaseous_server
                 throw new PathNotFound(PathName);
             }
 
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "INSERT INTO GameLibraries (Name, Path, DefaultPlatform, DefaultLibrary) VALUES (@name, @path, @defaultplatform, 0); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             dbDict.Add("name", Name);
@@ -96,28 +116,49 @@ 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)
             {
-                Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                // 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();
             }
         }
 
         public static LibraryItem GetLibrary(int LibraryId)
         {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "SELECT * FROM GameLibraries WHERE Id=@id";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             dbDict.Add("id", LibraryId);
@@ -143,6 +184,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,31 +1,43 @@
 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_tools;
+using gaseous_server.Models;
 using IGDB.Models;
-using MySqlX.XDevAPI;
-using Org.BouncyCastle.Utilities.IO.Pem;
+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_Directories = Directory.GetDirectories(ImportPath);
+				string[] importContents = Directory.GetFiles(ImportPath, "*.*", SearchOption.AllDirectories);
+
+                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) {
-					ImportGame.ImportGameFile(importContent, null, false);
+                int importCount = 1;
+				foreach (string importContent in importContents) {
+                    SetStatus(importCount, importContents.Length, "Importing file: " + importContent);
+
+					ImportGameFile(importContent, null);
+
+                    importCount += 1;
 				}
+                ClearStatus();
+
+                DeleteOrphanedDirectories(ImportPath);
             }
 			else
 			{
@@ -34,14 +46,9 @@ namespace gaseous_server.Classes
 			}
         }
 
-
-	}
-
-	public class ImportGame
+        public void ImportGameFile(string GameFileImportPath, IGDB.Models.Platform? OverridePlatform)
 		{
-        public static void ImportGameFile(string GameFileImportPath, IGDB.Models.Platform? OverridePlatform, bool IsDirectory = false)
-		{
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 			string sql = "";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
 
@@ -50,8 +57,6 @@ namespace gaseous_server.Classes
                 Logging.Log(Logging.LogType.Debug, "Import Game", "Skipping item " + GameFileImportPath);
             }
 			else
-			{
-				if (IsDirectory == false)
 			{
                 FileInfo fi = new FileInfo(GameFileImportPath);
                 Common.hashObject hash = new Common.hashObject(GameFileImportPath);
@@ -68,16 +73,33 @@ namespace gaseous_server.Classes
                     DataTable importDB = db.ExecuteCMD(sql, dbDict);
                     if ((Int64)importDB.Rows[0]["count"] > 0)
                     {
-                            if (!GameFileImportPath.StartsWith(Config.LibraryConfiguration.LibraryImportDirectory))
+                        // import source was the import directory
+                        if (GameFileImportPath.StartsWith(Config.LibraryConfiguration.LibraryImportDirectory))
                         {
-                                Logging.Log(Logging.LogType.Warning, "Import Game", "  " + GameFileImportPath + " already in database - skipping");
+                            Logging.Log(Logging.LogType.Warning, "Import Game", "  " + GameFileImportPath + " already in database - moving to " + Config.LibraryConfiguration.LibraryImportDuplicatesDirectory);
+
+                            string targetPathWithFileName = GameFileImportPath.Replace(Config.LibraryConfiguration.LibraryImportDirectory, Config.LibraryConfiguration.LibraryImportDuplicatesDirectory);
+                            string targetPath = Path.GetDirectoryName(targetPathWithFileName);
+
+                            if (!Directory.Exists(targetPath))
+                            {
+                                Directory.CreateDirectory(targetPath);
+                            }
+                            File.Move(GameFileImportPath, targetPathWithFileName, true);
+                        }
+                        
+                        // import source was the upload directory
+                        if (GameFileImportPath.StartsWith(Config.LibraryConfiguration.LibraryUploadDirectory))
+                        {
+                            Logging.Log(Logging.LogType.Warning, "Import Game", "  " + GameFileImportPath + " already in database - skipping import");
                         }
                     }
                     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;
@@ -96,7 +118,7 @@ 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);
@@ -126,150 +148,30 @@ namespace gaseous_server.Classes
                 }
 			}
 		}
+
+        public static IGDB.Models.Game SearchForGame(gaseous_server.Models.Signatures_Games Signature, long PlatformId, bool FullDownload)
+        {
+            if (Signature.Flags != null)
+            {
+                if (Signature.Flags.IGDBGameId != null && Signature.Flags.IGDBGameId != 0)
+                {
+                    // game was determined elsewhere - probably a Hasheous server
+                    try
+                    {
+                        return Games.GetGame(Signature.Flags.IGDBGameId, false, false, FullDownload);
                     }
-
-        public static Models.Signatures_Games GetFileSignature(Common.hashObject hash, FileInfo fi, string GameFileImportPath)
+                    catch (Exception ex)
                     {
-            Models.Signatures_Games discoveredSignature = _GetFileSignature(hash, fi, GameFileImportPath);
-
-            if ((Path.GetExtension(GameFileImportPath) == ".zip") && (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, Path.GetRandomFileName());
-                if (!Directory.Exists(ExtractPath)) { Directory.CreateDirectory(ExtractPath); }
-                ZipFile.ExtractToDirectory(GameFileImportPath, ExtractPath);
-
-                // 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;
-                    }
-                }
-
-                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);
+                        Logging.Log(Logging.LogType.Warning, "Import Game", "Provided game id resulted in a failed game lookup", ex);
                     }
                 }
             }
-            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)
@@ -392,9 +294,9 @@ 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 gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
             string sql = "";
 
@@ -405,7 +307,7 @@ namespace gaseous_server.Classes
                 sql = "INSERT INTO Games_Roms (PlatformId, GameId, Name, Size, CRC, MD5, SHA1, DevelopmentStatus, Attributes, RomType, RomTypeMedia, MediaLabel, Path, MetadataSource, MetadataGameName, MetadataVersion, LibraryId) VALUES (@platformid, @gameid, @name, @size, @crc, @md5, @sha1, @developmentstatus, @Attributes, @romtype, @romtypemedia, @medialabel, @path, @metadatasource, @metadatagamename, @metadataversion, @libraryid); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
             } else
             {
-                sql = "UPDATE Games_Roms SET PlatformId=platformid, GameId=@gameid, Name=@name, Size=@size, DevelopmentStatus=@developmentstatus, Attributes=@Attributes, RomType=@romtype, RomTypeMedia=@romtypemedia, MediaLabel=@medialabel, MetadataSource=@metadatasource, MetadataGameName=@metadatagamename, MetadataVersion=@metadataversion WHERE Id=@id;";
+                sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid, Name=@name, Size=@size, DevelopmentStatus=@developmentstatus, Attributes=@Attributes, RomType=@romtype, RomTypeMedia=@romtypemedia, MediaLabel=@medialabel, MetadataSource=@metadatasource, MetadataGameName=@metadatagamename, MetadataVersion=@metadataversion WHERE Id=@id;";
                 dbDict.Add("id", UpdateId);
             }
             dbDict.Add("platformid", Common.ReturnValueIfNull(determinedPlatform.Id, 0));
@@ -517,7 +419,7 @@ namespace gaseous_server.Classes
 						File.Move(romPath, DestinationPath);
 
 						// update the db
-						Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+						Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 						string sql = "UPDATE Games_Roms SET Path=@path WHERE Id=@id";
 						Dictionary<string, object> dbDict = new Dictionary<string, object>();
 						dbDict.Add("id", RomId);
@@ -535,14 +437,14 @@ namespace gaseous_server.Classes
             }
         }
 
-		public static void OrganiseLibrary()
+		public void OrganiseLibrary()
 		{
             Logging.Log(Logging.LogType.Information, "Organise Library", "Starting default library organisation");
 
             GameLibrary.LibraryItem library = GameLibrary.GetDefaultLibrary;
 
             // move rom files to their new location
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "SELECT * FROM Games_Roms WHERE LibraryId = @libraryid";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             dbDict.Add("libraryid", library.Id);
@@ -550,13 +452,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"]);
-                    long RomId = (long)dr["id"];
+                    SetStatus(i, romDT.Rows.Count, "Processing file " + romDT.Rows[i]["name"]);
+					Logging.Log(Logging.LogType.Information, "Organise Library", "(" + i + "/" + romDT.Rows.Count + ") Processing ROM " + romDT.Rows[i]["name"]);
+                    long RomId = (long)romDT.Rows[i]["id"];
 					MoveGameFile(RomId);
 				}
 			}
+            ClearStatus();
 
 			// clean up empty directories
 			DeleteOrphanedDirectories(GameLibrary.GetDefaultLibrary.Path);
@@ -564,24 +468,103 @@ namespace gaseous_server.Classes
             Logging.Log(Logging.LogType.Information, "Organise Library", "Finsihed default library organisation");
         }
 
-        private static void DeleteOrphanedDirectories(string startLocation)
+        public static void DeleteOrphanedDirectories(string startLocation)
         {
             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 void LibraryScan(GameLibrary.LibraryItem? singleLibrary = null)
         {
-            foreach (GameLibrary.LibraryItem library in GameLibrary.GetLibraries)
+            int maxWorkers = Config.MetadataConfiguration.MaxLibraryScanWorkers;
+
+            List<GameLibrary.LibraryItem> libraries = new List<GameLibrary.LibraryItem>();
+            if (singleLibrary == null)
             {
-                Logging.Log(Logging.LogType.Information, "Library Scan", "Starting library scan. Library " + library.Name);
+                libraries.AddRange(GameLibrary.GetLibraries);
+            }
+            else
+            {
+                libraries.Add(singleLibrary);
+            }
+
+            // setup background tasks for each library
+            foreach (GameLibrary.LibraryItem library in libraries)
+            {
+                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);
+                queue.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> queueItems = new List<ProcessQueue.QueueItem>();
+                    queueItems.AddRange(ProcessQueue.QueueItems);
+                    foreach (ProcessQueue.QueueItem item in queueItems)
+                    {
+                        if (item.ItemType == ProcessQueue.QueueItemType.LibraryScanWorker)
+                        {
+                            currentWorkerCount += 1;
+                        }
+                    }
+                    if (currentWorkerCount >= maxWorkers)
+                    {
+                        allowContinue = false;
+                        Thread.Sleep(60000);
+                    }
+                } while (allowContinue == false);
+            }
+
+            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");
+        }
+
+        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);
 
@@ -616,14 +599,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);
@@ -646,94 +631,76 @@ 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);
-
-                            Logging.Log(Logging.LogType.Information, "Library Scan", " Orphaned file found in library: " + LibraryFile);
+                        FileSignature fileSignature = new FileSignature();
+                        gaseous_server.Models.Signatures_Games sig = fileSignature.GetFileSignature(library, hash, fi, 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 (determinedPlatform == null)
+                            if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0 )
                             {
-                                if (library.DefaultPlatformId == 0)
-                                {
-                                    determinedPlatform = new IGDB.Models.Platform();
-                                    determinedGame = SearchForGame(sig.Game.Name, sig.Flags.IGDBPlatformId);
+                                // no platform discovered in the signature
+                                PlatformId = library.DefaultPlatformId;
                             }
                             else
                             {
-                                    determinedPlatform = Platforms.GetPlatform(library.DefaultPlatformId);
-                                    determinedGame = SearchForGame(sig.Game.Name, library.DefaultPlatformId);
-                                }
-                            }
-                            else
-                            {
-                                determinedGame = SearchForGame(sig.Game.Name, (long)determinedPlatform.Id);
+                                // use the platform discovered in the signature
+                                PlatformId = sig.Flags.IGDBPlatformId;
                             }
+                            determinedPlatform = Platforms.GetPlatform(PlatformId);
+
+                            IGDB.Models.Game determinedGame = SearchForGame(sig, PlatformId, true);
 
                             StoreROM(library, hash, determinedGame, determinedPlatform, sig, 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))
                     {
-                            // file exists, so lets check to make sure the signature was matched, and update if a signature can be found
-                            if (
-                                romMetadataSource == gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType.None ||
-                                (int)dtRoms.Rows[i]["MetadataVersion"] == 1
-                            )
-                            {
-                                Common.hashObject hash = new Common.hashObject
-                                {
-                                    md5hash = (string)dtRoms.Rows[i]["MD5"],
-                                    sha1hash = (string)dtRoms.Rows[i]["SHA1"]
-                                };
-                                FileInfo fi = new FileInfo(romPath);
-
-                                Models.Signatures_Games sig = GetFileSignature(hash, fi, romPath);
-                                if (sig.Rom.SignatureSource != gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType.None)
-                                {
-                                    Logging.Log(Logging.LogType.Information, "Library Scan", " Update signature found for " + romPath);
-
-                                    // get discovered platform
-                                    IGDB.Models.Platform determinedPlatform = Metadata.Platforms.GetPlatform(sig.Flags.IGDBPlatformId);
-                                    if (determinedPlatform == null)
-                                    {
-                                        determinedPlatform = new IGDB.Models.Platform();
-                                    }
-
-                                    IGDB.Models.Game determinedGame = SearchForGame(sig.Game.Name, sig.Flags.IGDBPlatformId);
-
-                                    StoreROM(library, hash, determinedGame, determinedPlatform, sig, romPath, romId);
-                                }
-                            }
-
                         if (library.IsDefaultLibrary == true)
                         {
                             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
@@ -747,11 +714,92 @@ 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 void Rematcher(bool ForceExecute = false)
+        {
+            // rescan all titles with an unknown platform or title and see if we can get a match
+            Logging.Log(Logging.LogType.Information, "Rematch Scan", "Rematch scan starting");
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+
+            foreach (GameLibrary.LibraryItem library in GameLibrary.GetLibraries)
+            {
+                Logging.Log(Logging.LogType.Information, "Rematch Scan", "Rematch on library " + library.Name);
+
+                string sql = "";
+                if (ForceExecute == false)
+                {
+                    sql = "SELECT * FROM Games_Roms WHERE (PlatformId = 0 AND GameId <> 0) OR (((PlatformId = 0 OR GameId = 0) AND MetadataSource = 0) OR (PlatformId = 0 AND GameId = 0)) AND (LastMatchAttemptDate IS NULL OR LastMatchAttemptDate < @lastmatchattemptdate) AND LibraryId = @libraryid LIMIT 100;";
+                }
+                else
+                {
+                    sql = "SELECT * FROM Games_Roms WHERE (PlatformId = 0 AND GameId <> 0) OR (((PlatformId = 0 OR GameId = 0) AND MetadataSource = 0) OR (PlatformId = 0 AND GameId = 0)) AND LibraryId = @libraryid;";
+                }
+                Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                dbDict.Add("lastmatchattemptdate", DateTime.UtcNow.AddDays(-7));
+                dbDict.Add("libraryid", library.Id);
+                DataTable data = db.ExecuteCMD(sql, dbDict);
+                int StatusCount = -0;
+                foreach (DataRow row in data.Rows)
+                {
+                    SetStatus(StatusCount, data.Rows.Count, "Running rematcher");
+
+                    // get rom info
+                    long romId = (long)row["Id"];
+                    string romPath = (string)row["Path"];
+                    Common.hashObject hash = new Common.hashObject
+                    {
+                        md5hash = (string)row["MD5"],
+                        sha1hash = (string)row["SHA1"]
+                    };
+                    FileInfo fi = new FileInfo(romPath);
+
+                    Logging.Log(Logging.LogType.Information, "Rematch Scan", "Running rematch against " + romPath);
+
+                    // determine rom signature
+                    FileSignature fileSignature = new FileSignature();
+                    gaseous_server.Models.Signatures_Games sig = fileSignature.GetFileSignature(library, hash, fi, romPath);
+
+                    // get discovered platform
+                    long PlatformId;
+                    IGDB.Models.Platform determinedPlatform;
+                    
+                    if (sig.Flags.IGDBPlatformId == null || sig.Flags.IGDBPlatformId == 0 )
+                    {
+                        // no platform discovered in the signature
+                        PlatformId = library.DefaultPlatformId;
+                    }
+                    else
+                    {
+                        // use the platform discovered in the signature
+                        PlatformId = sig.Flags.IGDBPlatformId;
+                    }
+                    determinedPlatform = Platforms.GetPlatform(PlatformId);
+
+                    IGDB.Models.Game determinedGame = SearchForGame(sig, PlatformId, true);
+
+                    StoreROM(library, hash, determinedGame, determinedPlatform, sig, romPath, romId);
+
+                    string attemptSql = "UPDATE Games_Roms SET LastMatchAttemptDate=@lastmatchattemptdate WHERE Id=@id;";
+                    Dictionary<string, object> dbLastAttemptDict = new Dictionary<string, object>();
+                    dbLastAttemptDict.Add("id", romId);
+                    dbLastAttemptDict.Add("lastmatchattemptdate", DateTime.UtcNow);
+                    db.ExecuteCMD(attemptSql, dbLastAttemptDict);
+
+                    StatusCount += 1;
+                }
+                ClearStatus();
+
+                Logging.Log(Logging.LogType.Information, "Rematch Scan", "Rematch scan completed");
+                ClearStatus();
+            }
         }
     }
 }

gaseous-server/Classes/Logging.cs

@@ -0,0 +1,364 @@
+using System;
+using System.Data;
+using System.Diagnostics;
+using System.Reflection;
+using System.Reflection.Metadata.Ecma335;
+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)
+        {
+            LogItem logItem = new LogItem
+            {
+                EventTime = DateTime.UtcNow,
+                EventType = EventType,
+                Process = ServerProcess,
+                Message = Message,
+                ExceptionValue = Common.ReturnValueIfNull(ExceptionValue, "").ToString()
+            };
+
+            bool AllowWrite = false;
+            if (EventType == LogType.Debug)
+            {
+                if (Config.LoggingConfiguration.DebugLogging == true)
+                {
+                    AllowWrite = true;
+                }
+            }
+            else
+            {
+                AllowWrite = true;
+            }
+
+            if (AllowWrite == true)
+            {
+                // console output
+                string TraceOutput = logItem.EventTime.ToString("yyyyMMdd HHmmss") + ": " + logItem.EventType.ToString() + ": " + logItem.Process + ": " + logItem.Message;
+                if (logItem.ExceptionValue != null)
+                {
+                    TraceOutput += Environment.NewLine + logItem.ExceptionValue.ToString();
+                }
+                switch(logItem.EventType) {
+                    case LogType.Information:
+                        Console.ForegroundColor = ConsoleColor.Blue;
+                        break;
+
+                    case LogType.Warning:
+                        Console.ForegroundColor = ConsoleColor.Yellow;
+                        break;
+
+                    case LogType.Critical:
+                        Console.ForegroundColor = ConsoleColor.Red;
+                        break;
+
+                    case LogType.Debug:
+                        Console.ForegroundColor = ConsoleColor.Magenta;
+                        break;
+
+                }
+                Console.WriteLine(TraceOutput);
+                Console.ResetColor();
+
+                if (WriteToDiskOnly == true)
+                {
+                    LogToDiskOnly = true;
+                }
+
+                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 = "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("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
+                    {
+                        db.ExecuteCMD(sql, dbDict);
+                    }
+                    catch (Exception ex)
+                    {   
+                        LogToDisk(logItem, TraceOutput, ex);
+                    }
+                }
+                else
+                {
+                    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)
+        {
+            if (exception != null)
+            {
+                // dump the error
+                File.AppendAllText(Config.LogFilePath, logItem.EventTime.ToString("yyyyMMdd HHmmss") + ": " + logItem.EventType.ToString() + ": " + logItem.Process + ": " + logItem.Message + Environment.NewLine + exception.ToString());
+            
+
+                // something went wrong writing to the db
+                File.AppendAllText(Config.LogFilePath, logItem.EventTime.ToString("yyyyMMdd HHmmss") + ": The following event was unable to be written to the log database:");
+            }
+
+            File.AppendAllText(Config.LogFilePath, TraceOutput);
+        }
+
+        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 = "";
+
+            List<string> whereClauses = new List<string>();
+
+            // handle status criteria
+            if (model.Status != null)
+            {
+                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
+            {
+                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;";
+            }
+            DataTable dataTable = db.ExecuteCMD(sql, dbDict);
+
+            List<LogItem> logs = new List<LogItem>();
+            foreach (DataRow row in dataTable.Rows)
+            {
+                LogItem log = new LogItem
+                {
+                    Id = (long)row["Id"],
+                    EventTime = DateTime.Parse(((DateTime)row["EventTime"]).ToString("yyyy-MM-ddThh:mm:ss") + 'Z'),
+                    EventType = (LogType)row["EventType"],
+                    Process = (string)row["Process"],
+                    Message = (string)row["Message"],
+                    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);
+            }
+
+            return logs;
+        }
+
+        public enum LogType
+        {
+            Information = 0,
+            Debug = 1,
+            Warning = 2,
+            Critical = 3
+        }
+
+        public class LogItem
+        {
+            public long Id { get; set; }
+            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
+            {
+                get
+                {
+                    return _Message;
+                }
+                set
+                {
+                    _Message = value;
+                }
+            }
+            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

@@ -0,0 +1,106 @@
+using System;
+using System.Data;
+using gaseous_server.Models;
+using Microsoft.VisualStudio.Web.CodeGeneration;
+
+namespace gaseous_server.Classes
+{
+	public class Maintenance : QueueItemStatus
+    {
+        const int MaxFileAge = 30;
+
+        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
+            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
+            sql = "DELETE FROM ServerLogs WHERE EventTime < @EventRetentionDate;";
+            dbDict.Add("EventRetentionDate", DateTime.UtcNow.AddDays(Config.LoggingConfiguration.LogRetention * -1));
+            db.ExecuteCMD(sql, dbDict);
+
+            // delete files and directories older than 7 days in PathsToClean
+            List<string> PathsToClean = new List<string>();
+            PathsToClean.Add(Config.LibraryConfiguration.LibraryUploadDirectory);
+            PathsToClean.Add(Config.LibraryConfiguration.LibraryTempDirectory);
+
+            foreach (string PathToClean in PathsToClean)
+            {
+                Logging.Log(Logging.LogType.Information, "Maintenance", "Removing files older than " + MaxFileAge + " days from " + PathToClean);
+
+                // get content
+                // files first
+                foreach (string filePath in Directory.GetFiles(PathToClean))
+                {
+                    FileInfo fileInfo = new FileInfo(filePath);
+                    if (fileInfo.LastWriteTimeUtc.AddDays(MaxFileAge) < DateTime.UtcNow)
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Maintenance", "Deleting file " + filePath);
+                        File.Delete(filePath);
+                    }
+                }
+
+                // now directories
+                foreach (string dirPath in Directory.GetDirectories(PathToClean))
+                {
+                    DirectoryInfo directoryInfo = new DirectoryInfo(dirPath);
+                    if (directoryInfo.LastWriteTimeUtc.AddDays(MaxFileAge) < DateTime.UtcNow)
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Maintenance", "Deleting directory " + directoryInfo);
+                        Directory.Delete(dirPath, true);
+                    }
+                }
+            }
+        }
+
+        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");
+            sql = "SHOW FULL TABLES WHERE Table_Type = 'BASE TABLE';";
+            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);
+                foreach (DataRow responseRow in response.Rows)
+                {
+                    string retVal = "";
+                    for (int i = 0; i < responseRow.ItemArray.Length; i++)
+                    {
+                        retVal += responseRow.ItemArray[i] + "; ";
+                    }
+                    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,312 @@
+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.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

@@ -1,10 +1,9 @@
 using System;
 using System.Reflection;
-using gaseous_tools;
+using System.Text.Json.Serialization;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+using Microsoft.CodeAnalysis.Classification;
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -16,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))
@@ -84,7 +77,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<AgeRating>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -118,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;
@@ -154,6 +148,44 @@ namespace gaseous_server.Classes.Metadata
             public AgeRatingTitle RatingTitle { get; set; }
             public string[] Descriptions { get; set; }
         }
+
+        public static void PopulateAgeMap()
+        {
+            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);
+                            
+                            foreach (AgeRatingTitle ageRatingTitle in ageRatingTitles)
+                            {
+                                dbDict.Clear();
+                                dbDict.Add("AgeGroupId", ageGrouping.Key);
+                                dbDict.Add("ClassificationBoardId", ageRatingCategory);
+                                dbDict.Add("RatingId", ageRatingTitle);
+
+                                sql = "INSERT INTO ClassificationMap (AgeGroupId, ClassificationBoardId, RatingId) VALUES (@AgeGroupId, @ClassificationBoardId, @RatingId);";
+                                db.ExecuteCMD(sql, dbDict);
+                            }
+                        }
+                    }
+                }
+            }
+        }
 	}
 }
 

gaseous-server/Classes/Metadata/AgeRatingContentDescriptions.cs

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<AgeRatingContentDescription>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<AlternativeName>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,13 +13,7 @@ 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 Artwork? GetArtwork(long? Id, string LogoPath)
+        public static Artwork? GetArtwork(long? Id, string ImagePath, bool GetImages)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -29,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();
@@ -69,23 +61,24 @@ 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);
+                        forceImageDownload = true;
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Artwork>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -96,11 +89,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);
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med, returnValue.ImageId);
-                GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_original, returnValue.ImageId);
+                if ((!File.Exists(localFile)) || forceImageDownload == true)
+                {
+                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Artwork download forced.");
+
+                    Communications comms = new Communications();
+                    comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
+                }
             }
 
             return returnValue;
@@ -112,64 +111,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

@@ -1,26 +1,18 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Collection>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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,593 @@
+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
+                    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
+                        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

@@ -1,5 +1,4 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
 
@@ -13,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))
@@ -81,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Company>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -112,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,13 +13,7 @@ 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 CompanyLogo? GetCompanyLogo(long? Id, string LogoPath)
+        public static CompanyLogo? GetCompanyLogo(long? Id, string ImagePath)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -29,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();
@@ -72,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);
@@ -82,13 +74,13 @@ namespace gaseous_server.Classes.Metadata
                 case Storage.CacheStatus.Expired:
                     try
                     {
-                        returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                         Storage.NewCacheValue(returnValue, true);
                         forceImageDownload = true;
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<CompanyLogo>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -99,13 +91,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)
-                {
-                    GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_thumb);
-                    GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med);
-                }
+                Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Company logo download forced.");
+
+                Communications comms = new Communications();
+                comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
             }
 
             return returnValue;
@@ -117,64 +110,15 @@ namespace gaseous_server.Classes.Metadata
             slug
         }
 
-        private static async Task<CompanyLogo?> GetObjectFromServer(string WhereClause, string LogoPath)
-        {
-            // get CompanyLogo metadata
-            var results = await igdb.QueryAsync<CompanyLogo>(IGDBClient.Endpoints.CompanyLogos, query: fieldList + " " + WhereClause + ";");
-            if (results.Length > 0)
+        private static async Task<CompanyLogo> GetObjectFromServer(string WhereClause, string ImagePath)
         {
+            // get Artwork metadata
+            Communications comms = new Communications();
+            var results = await comms.APIComm<CompanyLogo>(IGDBClient.Endpoints.CompanyLogos, fieldList, WhereClause);
             var result = results.First();
 
-                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,27 +1,21 @@
 using System;
-using gaseous_tools;
+using System.Net;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+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(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
-
-        public static Cover? GetCover(long? Id, string LogoPath)
+        public static Cover? GetCover(long? Id, string ImagePath, bool GetImages)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -29,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();
@@ -69,23 +63,24 @@ 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);
                         forceImageDownload = true;
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Cover>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -96,11 +91,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);
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med, returnValue.ImageId);
-                GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_original, returnValue.ImageId);
+                if ((!File.Exists(localFile)) || forceImageDownload == true)
+                {
+                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Cover download forced.");
+
+                    // check for presence of image file - download if absent or force download is true
+                    List<Communications.IGDBAPI_ImageSize> imageSizes = new List<Communications.IGDBAPI_ImageSize>{
+                        Communications.IGDBAPI_ImageSize.cover_big,
+                        Communications.IGDBAPI_ImageSize.cover_small,
+                        Communications.IGDBAPI_ImageSize.original
+                    };
+
+                    Communications comms = new Communications();
+                    foreach (Communications.IGDBAPI_ImageSize size in imageSizes)
+                    {
+                        localFile = Path.Combine(ImagePath, size.ToString(), returnValue.ImageId + ".jpg");
+                        if ((!File.Exists(localFile)) || forceImageDownload == true)
+                        {
+                            comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, size, null);
+                        }
+                    }
+                }
             }
 
             return returnValue;
@@ -112,63 +126,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -85,7 +77,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<ExternalGame>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -108,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Franchise>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<GameMode>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<GameVideo>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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,6 +1,5 @@
 using System;
 using System.Data;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
 
@@ -8,18 +7,18 @@ 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,collection,collections,cover,created_at,dlcs,expanded_games,expansions,external_games,first_release_date,follows,forks,franchise,franchises,game_engines,game_localizations,game_modes,genres,hypes,involved_companies,keywords,language_supports,multiplayer_modes,name,parent_game,platforms,player_perspectives,ports,rating,rating_count,release_dates,remakes,remasters,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;";
 
         public Games()
         {
 
         }
 
-        private static IGDBClient igdb = new IGDBClient(
-                    // Found in Twitch Developer portal for your app
-                    Config.IGDB.ClientId,
-                    Config.IGDB.Secret
-                );
+        public class InvalidGameId : Exception
+        { 
+            public InvalidGameId(long Id) : base("Unable to find Game by id " + Id)
+            {}
+        }
 
         public static Game? GetGame(long Id, bool getAllMetadata, bool followSubGames, bool forceRefresh)
         {
@@ -99,36 +98,85 @@ 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, forceRefresh);
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
                     }
                     return returnValue;
                 case Storage.CacheStatus.Current:
-                    return Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
+                    returnValue = Storage.GetCacheValue<Game>(returnValue, "id", (long)searchValue);
+                    UpdateSubClasses(returnValue, false, false, false);
+                    return returnValue;
                 default:
                     throw new Exception("How did you get here?");
             }
         }
 
-        private static void UpdateSubClasses(Game Game, bool getAllMetadata, bool followSubGames)
+        private static void UpdateSubClasses(Game Game, bool getAllMetadata, bool followSubGames, bool forceRefresh)
         {
+            // required metadata
             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 (getAllMetadata == true)
+            if (Game.Genres != null)
             {
+                foreach (long GenreId in Game.Genres.Ids)
+                {
+                    Genre GameGenre = Genres.GetGenres(GenreId);
+                }
+            }
+
+            if (Game.GameModes != null)
+            {
+                foreach (long gameModeId in Game.GameModes.Ids)
+                {
+                    GameMode gameMode = GameModes.GetGame_Modes(gameModeId);
+                }
+            }
+
+            if (Game.MultiplayerModes != null)
+            {
+                foreach (long multiplayerModeId in Game.MultiplayerModes.Ids)
+                {
+                    MultiplayerMode multiplayerMode = MultiplayerModes.GetGame_MultiplayerModes(multiplayerModeId);
+                }
+            }
+
+            if (Game.PlayerPerspectives != null)
+            {
+                foreach (long PerspectiveId in Game.PlayerPerspectives.Ids)
+                {
+                    PlayerPerspective GamePlayPerspective = PlayerPerspectives.GetGame_PlayerPerspectives(PerspectiveId);
+                }
+            }
+
+            if (Game.Themes != null)
+            {
+                foreach (long ThemeId in Game.Themes.Ids)
+                {
+                    Theme GameTheme = Themes.GetGame_Themes(ThemeId);
+                }
+            }
+
             if (Game.AgeRatings != null)
             {
                 foreach (long AgeRatingId in Game.AgeRatings.Ids)
@@ -136,7 +184,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)
@@ -149,7 +209,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);
+                        }
                     }
                 }
 
@@ -196,14 +263,6 @@ namespace gaseous_server.Classes.Metadata
                     }
                 }
 
-                if (Game.Genres != null)
-                {
-                    foreach (long GenreId in Game.Genres.Ids)
-                    {
-                        Genre GameGenre = Genres.GetGenres(GenreId);
-                    }
-                }
-
                 if (Game.InvolvedCompanies != null)
                 {
                     foreach (long involvedCompanyId in Game.InvolvedCompanies.Ids)
@@ -212,22 +271,6 @@ namespace gaseous_server.Classes.Metadata
                     }
                 }
 
-                if (Game.GameModes != null)
-                {
-                    foreach (long gameModeId in Game.GameModes.Ids)
-                    {
-                        GameMode gameMode = GameModes.GetGame_Modes(gameModeId);
-                    }
-                }
-
-                if (Game.MultiplayerModes != null)
-                {
-                    foreach (long multiplayerModeId in Game.MultiplayerModes.Ids)
-                    {
-                        MultiplayerMode multiplayerMode = MultiplayerModes.GetGame_MultiplayerModes(multiplayerModeId);
-                    }
-                }
-
                 if (Game.Platforms != null)
                 {
                     foreach (long PlatformId in Game.Platforms.Ids)
@@ -236,27 +279,18 @@ namespace gaseous_server.Classes.Metadata
                     }
                 }
 
-                if (Game.PlayerPerspectives != null)
-                {
-                    foreach (long PerspectiveId in Game.PlayerPerspectives.Ids)
-                    {
-                        PlayerPerspective GamePlayPerspective = PlayerPerspectives.GetGame_PlayerPerspectives(PerspectiveId);
-                    }
-                }
-
                 if (Game.Screenshots != null)
                 {
                     foreach (long ScreenshotId in Game.Screenshots.Ids)
                     {
-                        Screenshot GameScreenshot = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game));
-                    }
-                }
-
-                if (Game.Themes != null)
+                        try
                         {
-                    foreach (long ThemeId in Game.Themes.Ids)
+                        Screenshot GameScreenshot = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
+                        }
+                        catch (Exception ex)
                         {
-                        Theme GameTheme = Themes.GetGame_Themes(ThemeId);
+                            Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch screenshot id: " + ScreenshotId, ex);
+                        }
                     }
                 }
 
@@ -279,46 +313,212 @@ 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 = "";
-            searchBody += "fields id,name,slug,platforms,summary; ";
+            string whereClause = "";
+            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 + "\"; ";
-                    searchBody += "where platforms = (" + PlatformId + ");";
+                    whereClause = "PlatformsId = @platformid AND MATCH(`Name`) AGAINST (@gamename)";
+                    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<KeyValuePair<long, string>> GetAvailablePlatforms(long GameId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT DISTINCT Games_Roms.PlatformId, Platform.`Name` FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE Games_Roms.GameId = @gameid ORDER BY Platform.`Name`;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("gameid", GameId);
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+
+            List<KeyValuePair<long, string>> platforms = new List<KeyValuePair<long, string>>();
+            foreach (DataRow row in data.Rows)
+            {
+                KeyValuePair<long, string> valuePair = new KeyValuePair<long, string>((long)row["PlatformId"], (string)row["Name"]);
+				platforms.Add(valuePair);
+            }
+
+            return platforms;
+        }
+
         public enum SearchType
         {
             where = 0,
@@ -326,5 +526,51 @@ 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.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 string Name { get; set; }
+            public string Slug { 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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Genre>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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

@@ -1,5 +1,4 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
 
@@ -13,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))
@@ -81,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<InvolvedCompany>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -114,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -82,7 +74,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<MultiplayerMode>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -105,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,13 +13,7 @@ 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 PlatformLogo? GetPlatformLogo(long? Id, string LogoPath)
+        public static PlatformLogo? GetPlatformLogo(long? Id, string ImagePath)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -29,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();
@@ -72,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);
@@ -82,13 +74,13 @@ namespace gaseous_server.Classes.Metadata
                 case Storage.CacheStatus.Expired:
                     try
                     {
-                        returnValue = await GetObjectFromServer(WhereClause, LogoPath);
+                        returnValue = await GetObjectFromServer(WhereClause, ImagePath);
                         Storage.NewCacheValue(returnValue, true);
                         forceImageDownload = true;
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<PlatformLogo>(returnValue, "id", (long)searchValue);
                     }
                     break;  
@@ -101,10 +93,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);
-                    GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med);
+                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Platform logo download forced.");
+
+                    Communications comms = new Communications();
+                    comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
                 }
             }
 
@@ -117,64 +113,15 @@ namespace gaseous_server.Classes.Metadata
             slug
         }
 
-        private static async Task<PlatformLogo?> GetObjectFromServer(string WhereClause, string LogoPath)
-        {
-            // get PlatformLogo metadata
-            var results = await igdb.QueryAsync<PlatformLogo>(IGDBClient.Endpoints.PlatformLogos, query: fieldList + " " + WhereClause + ";");
-            if (results.Length > 0)
+        private static async Task<PlatformLogo> GetObjectFromServer(string WhereClause, string ImagePath)
         {
+            // get Artwork metadata
+            Communications comms = new Communications();
+            var results = await comms.APIComm<PlatformLogo>(IGDBClient.Endpoints.PlatformLogos, fieldList, WhereClause);
             var result = results.First();
 
-                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

@@ -1,6 +1,5 @@
 using System;
 using System.Data;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
 
@@ -14,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 PlatformVersion? GetPlatformVersion(long Id, Platform ParentPlatform)
         {
             if (Id == 0)
@@ -86,7 +79,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<PlatformVersion>(returnValue, "id", (long)searchValue);
                     }
                     return returnValue;
@@ -100,9 +93,16 @@ namespace gaseous_server.Classes.Metadata
         private static void UpdateSubClasses(Platform ParentPlatform, PlatformVersion platformVersion)
         {
             if (platformVersion.PlatformLogo != null)
+            {
+                try
                 {
                     PlatformLogo platformLogo = PlatformLogos.GetPlatformLogo(platformVersion.PlatformLogo.Id, Path.Combine(Config.LibraryConfiguration.LibraryMetadataDirectory_Platform(ParentPlatform), "Versions", platformVersion.Slug));
                 }
+                catch (Exception ex)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Platform Update", "Unable to fetch platform logo", ex);
+                }
+            }
         }
 
         private enum SearchUsing
@@ -114,7 +114,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

@@ -1,7 +1,6 @@
 using System;
 using System.Data;
 using System.Net;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
 
@@ -16,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 Platform? GetPlatform(long Id, bool forceRefresh = false)
 		{
             if (Id == 0)
@@ -45,10 +38,18 @@ namespace gaseous_server.Classes.Metadata
                 }
             }
             else
+            {
+                try
                 {
                     Task<Platform> RetVal = _GetPlatform(SearchUsing.id, Id, forceRefresh);
                     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)
@@ -130,9 +131,16 @@ namespace gaseous_server.Classes.Metadata
             }
 
             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)
@@ -169,11 +177,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -84,7 +76,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<PlayerPerspective>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -107,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

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,13 +13,7 @@ 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 Screenshot? GetScreenshot(long? Id, string LogoPath)
+        public static Screenshot? GetScreenshot(long? Id, string ImagePath, bool GetImages)
         {
             if ((Id == 0) || (Id == null))
             {
@@ -29,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();
@@ -69,24 +61,24 @@ 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);
                         forceImageDownload = true;
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         returnValue = Storage.GetCacheValue<Screenshot>(returnValue, "id", (long)searchValue);
                     }
                     break;
@@ -97,11 +89,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);
-                //GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_logo_med, returnValue.ImageId);
-                GetImageFromServer(returnValue.Url, LogoPath, LogoSize.t_original, returnValue.ImageId);
+                if ((!File.Exists(localFile)) || forceImageDownload == true)
+                {
+                    Logging.Log(Logging.LogType.Information, "Metadata: " + returnValue.GetType().Name, "Screenshot download forced.");
+
+                    Communications comms = new Communications();
+                    comms.GetSpecificImageFromServer(ImagePath, returnValue.ImageId, Communications.IGDBAPI_ImageSize.original, null);
+                }
             }
 
             return returnValue;
@@ -113,64 +111,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

@@ -1,9 +1,9 @@
 using System;
 using System.Data;
 using System.Reflection;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -48,7 +48,7 @@ namespace gaseous_server.Classes.Metadata
 
         private static CacheStatus _GetCacheStatus(string Endpoint, string SearchField, object SearchValue)
 		{
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
 			string sql = "SELECT lastUpdated FROM " + Endpoint + " WHERE " + SearchField + " = @" + SearchField;
 
@@ -134,6 +134,9 @@ namespace gaseous_server.Classes.Metadata
                                     newDict = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(newObjectValue);
 									newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(newDict["Ids"]);
                                     objectDict[key.Key] = newObjectValue;
+
+                                    StoreRelations(ObjectTypeName, key.Key, (long)objectDict["Id"], newObjectValue);
+
                                     break;
 								case "int32[]":
                                     newObjectValue = Newtonsoft.Json.JsonConvert.SerializeObject(objectValue);
@@ -156,7 +159,7 @@ namespace gaseous_server.Classes.Metadata
 			}
 
             // execute sql
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 			db.ExecuteCMD(sql, objectDict);
         }
 
@@ -164,7 +167,7 @@ namespace gaseous_server.Classes.Metadata
 		{
             string Endpoint = EndpointType.GetType().Name;
 
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
             string sql = "SELECT * FROM " + Endpoint + " WHERE " + SearchField + " = @" + SearchField;
 
@@ -181,7 +184,9 @@ namespace gaseous_server.Classes.Metadata
             else
             {
 				DataRow dataRow = dt.Rows[0];
-                return BuildCacheObject<T>(EndpointType, dataRow);
+                object returnObject = BuildCacheObject<T>(EndpointType, dataRow);
+                
+                return (T)returnObject;
             }
         }
 
@@ -364,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;
@@ -380,6 +394,52 @@ namespace gaseous_server.Classes.Metadata
 
             return EndpointType;
         }
+
+        private static void StoreRelations(string PrimaryTable, string SecondaryTable, long ObjectId, string Relations)
+        {
+            string TableName = "Relation_" + PrimaryTable + "_" + SecondaryTable;
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM information_schema.tables WHERE table_schema = '" + Config.DatabaseConfiguration.DatabaseName + "' AND table_name = '" + TableName + "';";
+            DataTable data = db.ExecuteCMD(sql);
+            if (data.Rows.Count == 0)
+            {
+                // table doesn't exist, create it
+                sql = "CREATE TABLE `" + Config.DatabaseConfiguration.DatabaseName + "`.`" + TableName + "` (`" + PrimaryTable + "Id` BIGINT NOT NULL, `" + SecondaryTable + "Id` BIGINT NOT NULL, PRIMARY KEY (`" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`), INDEX `idx_PrimaryColumn` (`" + PrimaryTable + "Id` ASC) VISIBLE);";
+                db.ExecuteCMD(sql);
+            }
+            else
+            {
+                // clean existing records for this object
+                sql = "DELETE FROM " + TableName + " WHERE `" + PrimaryTable + "Id` = @objectid";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                dbDict.Add("objectid", ObjectId);
+                db.ExecuteCMD(sql, dbDict);
+            }
+
+            // insert data
+            long[] RelationValues = Newtonsoft.Json.JsonConvert.DeserializeObject<long[]>(Relations);
+            foreach (long RelationValue in RelationValues)
+            {
+                sql = "INSERT INTO " + TableName + " (`" + PrimaryTable + "Id`, `" + SecondaryTable + "Id`) VALUES (@objectid, @relationvalue);";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                dbDict.Add("objectid", ObjectId);
+                dbDict.Add("relationvalue", RelationValue);
+                db.ExecuteCMD(sql, dbDict);
+            }
+        }
+
+        private class MemoryCacheObject
+        {
+            public object Object { get; set; }
+            public DateTime CreationTime { get; } = DateTime.UtcNow;
+            public DateTime ExpiryTime 
+            {
+                get
+                {
+                    return CreationTime.AddMinutes(60);
+                }
+            }
+        }
     }
 }
 

gaseous-server/Classes/Metadata/Themes.cs

@@ -1,9 +1,7 @@
 using System;
-using gaseous_tools;
 using IGDB;
 using IGDB.Models;
-using MySqlX.XDevAPI.Common;
-using static gaseous_tools.Config.ConfigFile;
+
 
 namespace gaseous_server.Classes.Metadata
 {
@@ -15,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))
@@ -85,7 +77,7 @@ namespace gaseous_server.Classes.Metadata
                     }
                     catch (Exception ex)
                     {
-                        gaseous_tools.Logging.Log(gaseous_tools.Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
+                        Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
                         return Storage.GetCacheValue<Theme>(returnValue, "id", (long)searchValue);
                     }
                 case Storage.CacheStatus.Current:
@@ -107,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

@@ -1,51 +1,74 @@
 using System;
 using System.Data;
 using gaseous_server.Models;
-using gaseous_tools;
 
 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 gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            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"] + ")");
-					Metadata.Games.GetGame((long)dr["id"], true, true, forceRefresh);
+					Logging.Log(Logging.LogType.Information, "Metadata Refresh", "(" + StatusCounter + "/" + dt.Rows.Count + "): Refreshing metadata for game " + dr["name"] + " (" + dr["id"] + ")");
+					Metadata.Games.GetGame((long)dr["id"], true, false, true);
 				}
 				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

@@ -0,0 +1,480 @@
+using System;
+using System.Data;
+using gaseous_signature_parser.models.RomSignatureObject;
+using Microsoft.VisualBasic;
+using IGDB.Models;
+using gaseous_server.Classes.Metadata;
+using System.IO.Compression;
+
+namespace gaseous_server.Classes
+{
+	public class RomMediaGroup
+    {
+        public class InvalidMediaGroupId : Exception
+        { 
+            public InvalidMediaGroupId(long Id) : base("Unable to find media group by id " + Id)
+            {}
+        }
+
+        public static GameRomMediaGroupItem CreateMediaGroup(long GameId, long PlatformId, List<long> RomIds)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "INSERT INTO RomMediaGroup (Status, PlatformId, GameId) VALUES (@status, @platformid, @gameid); SELECT CAST(LAST_INSERT_ID() AS SIGNED);";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("status", GameRomMediaGroupItem.GroupBuildStatus.WaitingForBuild);
+            dbDict.Add("gameid", GameId);
+            dbDict.Add("platformid", PlatformId);
+            DataTable mgInsert = db.ExecuteCMD(sql, dbDict);
+            long mgId = (long)mgInsert.Rows[0][0];
+            foreach (long RomId in RomIds)
+            {
+                try
+                {
+                    Roms.GameRomItem gameRomItem = Roms.GetRom(RomId);
+                    if (gameRomItem.PlatformId == PlatformId)
+                    {
+                        sql = "INSERT INTO RomMediaGroup_Members (GroupId, RomId) VALUES (@groupid, @romid);";
+                        dbDict.Clear();
+                        dbDict.Add("groupid", mgId);
+                        dbDict.Add("romid", RomId);
+                        db.ExecuteCMD(sql, dbDict);
+                    }
+                    else
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Media Group", "Unable to add ROM id " + RomId + " to group. ROM platform is different from group platform.");
+                    }
+                }
+                catch (Roms.InvalidRomId irid)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Media Group", "Unable to add ROM id " + RomId + " to group. ROM doesn't exist", irid);
+                }
+            }
+
+            StartMediaGroupBuild(mgId);
+
+            return GetMediaGroup(mgId);
+        }
+
+        public static GameRomMediaGroupItem GetMediaGroup(long Id, string userid = "")
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT DISTINCT RomMediaGroup.*, GameState.RomId AS GameStateRomId FROM gaseous.RomMediaGroup LEFT JOIN GameState ON RomMediaGroup.Id = GameState.RomId AND GameState.IsMediaGroup = 1 AND GameState.UserId = @userid WHERE RomMediaGroup.Id=@id;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "id", Id },
+                { "userid", userid }
+            };
+
+            DataTable dataTable = db.ExecuteCMD(sql, dbDict);
+
+            if (dataTable.Rows.Count == 0)
+            {
+                throw new InvalidMediaGroupId(Id);
+            }
+            else
+            {
+                GameRomMediaGroupItem mediaGroupItem = BuildMediaGroupFromRow(dataTable.Rows[0]);
+                return mediaGroupItem;
+            }
+        }
+
+        public static List<GameRomMediaGroupItem> GetMediaGroupsFromGameId(long GameId, string userid = "")
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT DISTINCT RomMediaGroup.*, GameState.RomId AS GameStateRomId FROM gaseous.RomMediaGroup LEFT JOIN GameState ON RomMediaGroup.Id = GameState.RomId AND GameState.IsMediaGroup = 1 AND GameState.UserId = @userid WHERE RomMediaGroup.GameId=@gameid;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>
+            {
+                { "gameid", GameId },
+                { "userid", userid }
+            };
+
+            DataTable dataTable = db.ExecuteCMD(sql, dbDict);
+
+            List<GameRomMediaGroupItem> mediaGroupItems = new List<GameRomMediaGroupItem>();
+
+            foreach (DataRow row in dataTable.Rows)
+            {
+                mediaGroupItems.Add(BuildMediaGroupFromRow(row));
+            }
+
+            mediaGroupItems.Sort((x, y) => x.Platform.CompareTo(y.Platform));
+
+            return mediaGroupItems;
+        }
+
+        public static GameRomMediaGroupItem EditMediaGroup(long Id, List<long> RomIds)
+        {
+            GameRomMediaGroupItem mg = GetMediaGroup(Id);
+
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+
+            // delete roms from group
+            sql = "DELETE FROM RomMediaGroup_Members WHERE GroupId=@groupid;";
+            dbDict.Clear();
+            dbDict.Add("groupid", Id);
+            db.ExecuteCMD(sql, dbDict);
+
+            // add roms to group
+            foreach (long RomId in RomIds)
+            {
+                try
+                {
+                    Roms.GameRomItem gameRomItem = Roms.GetRom(RomId);
+                    if (gameRomItem.PlatformId == mg.PlatformId)
+                    {
+                        sql = "INSERT INTO RomMediaGroup_Members (GroupId, RomId) VALUES (@groupid, @romid);";
+                        dbDict.Clear();
+                        dbDict.Add("groupid", Id);
+                        dbDict.Add("romid", RomId);
+                        db.ExecuteCMD(sql, dbDict);
+                    }
+                    else
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Media Group", "Unable to add ROM id " + RomId + " to group. ROM platform is different from group platform.");
+                    }
+                }
+                catch (Roms.InvalidRomId irid)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Media Group", "Unable to add ROM id " + RomId + " to group. ROM doesn't exist", irid);
+                }
+            }
+
+            // set group to rebuild
+            sql = "UPDATE RomMediaGroup SET Status=1 WHERE GroupId=@groupid;";
+            dbDict.Clear();
+            dbDict.Add("groupid", Id);
+            db.ExecuteCMD(sql, dbDict);
+
+            string MediaGroupZipPath = Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, Id + ".zip");
+            if (File.Exists(MediaGroupZipPath))
+            {
+                File.Delete(MediaGroupZipPath);
+            }
+
+            StartMediaGroupBuild(Id);
+
+            // return to caller
+            return GetMediaGroup(Id);
+        }
+
+        public static void DeleteMediaGroup(long Id)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "DELETE FROM RomMediaGroup WHERE Id=@id; DELETE FROM GameState WHERE RomId=@id AND IsMediaGroup=1;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("id", Id);
+            db.ExecuteCMD(sql, dbDict);
+
+            string MediaGroupZipPath = Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, Id + ".zip");
+            if (File.Exists(MediaGroupZipPath))
+            {
+                File.Delete(MediaGroupZipPath);
+            }
+        }
+
+        internal static GameRomMediaGroupItem BuildMediaGroupFromRow(DataRow row)
+        {
+            bool hasSaveStates = false;
+			if (row.Table.Columns.Contains("GameStateRomId"))
+			{
+				if (row["GameStateRomId"] != DBNull.Value)
+				{
+					hasSaveStates = true;
+				}
+			}
+
+            GameRomMediaGroupItem mediaGroupItem = new GameRomMediaGroupItem();
+            mediaGroupItem.Id = (long)row["Id"];
+            mediaGroupItem.Status = (GameRomMediaGroupItem.GroupBuildStatus)row["Status"];
+            mediaGroupItem.PlatformId = (long)row["PlatformId"];
+            mediaGroupItem.GameId = (long)row["GameId"];
+            mediaGroupItem.RomIds = new List<long>();
+            mediaGroupItem.Roms = new List<Roms.GameRomItem>();
+            mediaGroupItem.HasSaveStates = hasSaveStates;
+
+            // get members
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql = "SELECT * FROM RomMediaGroup_Members WHERE GroupId=@id;";
+            Dictionary<string, object> dbDict = new Dictionary<string, object>();
+            dbDict.Add("id", mediaGroupItem.Id);
+            DataTable data = db.ExecuteCMD(sql, dbDict);
+            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);
+                }
+            }
+
+            // check for a web emulator and update the romItem
+			foreach (Models.PlatformMapping.PlatformMapItem platformMapping in Models.PlatformMapping.PlatformMap)
+			{
+				if (platformMapping.IGDBId == mediaGroupItem.PlatformId)
+				{
+					if (platformMapping.WebEmulator != null)
+					{
+						mediaGroupItem.Emulator = platformMapping.WebEmulator;
+					}
+				}
+			}
+
+            return mediaGroupItem;
+        }
+
+        public static void StartMediaGroupBuild(long Id)
+        {
+            GameRomMediaGroupItem mediaGroupItem = GetMediaGroup(Id);
+
+            if (mediaGroupItem.Status != GameRomMediaGroupItem.GroupBuildStatus.Building)
+            {
+                // set collection item to waitingforbuild
+                Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+                string sql = "UPDATE RomMediaGroup SET Status=@bs WHERE Id=@id";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                dbDict.Add("id", Id);
+                dbDict.Add("bs", GameRomMediaGroupItem.GroupBuildStatus.WaitingForBuild);
+                db.ExecuteCMD(sql, dbDict);
+
+                // start background task
+                ProcessQueue.QueueItem queueItem = new ProcessQueue.QueueItem(ProcessQueue.QueueItemType.MediaGroupCompiler, 1, false, true);
+                queueItem.Options = Id;
+                queueItem.ForceExecute();
+                ProcessQueue.QueueItems.Add(queueItem);
+            }
+        }
+
+        public static void CompileMediaGroup(long Id)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+
+            GameRomMediaGroupItem mediaGroupItem = GetMediaGroup(Id);
+            if (mediaGroupItem.Status == GameRomMediaGroupItem.GroupBuildStatus.WaitingForBuild)
+            {
+                Game GameObject = Games.GetGame(mediaGroupItem.GameId, false, false, false);
+                Platform PlatformObject = Platforms.GetPlatform(mediaGroupItem.PlatformId, false);
+
+                Logging.Log(Logging.LogType.Information, "Media Group", "Beginning build of media group: " + GameObject.Name + " for platform " + PlatformObject.Name);
+
+                // set starting
+                string sql = "UPDATE RomMediaGroup SET Status=@bs WHERE Id=@id";
+                Dictionary<string, object> dbDict = new Dictionary<string, object>();
+                dbDict.Add("id", mediaGroupItem.Id);
+                dbDict.Add("bs", GameRomMediaGroupItem.GroupBuildStatus.Building);
+                db.ExecuteCMD(sql, dbDict);
+
+                string ZipFilePath = Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, mediaGroupItem.Id + ".zip");
+                string ZipFileTempPath = Path.Combine(Config.LibraryConfiguration.LibraryTempDirectory, mediaGroupItem.Id.ToString());
+
+                try
+                {
+                    // clean up if needed
+                    if (File.Exists(ZipFilePath))
+                    {
+                        Logging.Log(Logging.LogType.Warning, "Media Group", "Deleting existing build of media group: " + GameObject.Name + " for platform " + PlatformObject.Name);
+                        File.Delete(ZipFilePath);
+                    }
+
+                    if (Directory.Exists(ZipFileTempPath))
+                    {
+                        Directory.Delete(ZipFileTempPath, true);
+                    }
+
+                    // gather media group files
+                    Directory.CreateDirectory(ZipFileTempPath);
+                    List<Roms.GameRomItem> romItems = new List<Roms.GameRomItem>();
+                    List<string> M3UFileContents = new List<string>();
+                    foreach (long RomId in mediaGroupItem.RomIds)
+                    {
+                        Roms.GameRomItem rom = Roms.GetRom(RomId);
+                        if (File.Exists(rom.Path))
+                        {
+                            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);
+                        }
+                    }
+
+                    // build m3u
+                    romItems.Sort((a, b) =>
+                        {
+                            if (a.MediaDetail != null)
+                            {
+                                if (a.MediaDetail.Number != null && a.MediaDetail.Side != null)
+                                {
+                                    var firstCompare = a.MediaDetail.Number.ToString().CompareTo(b.MediaDetail.Number.ToString());
+                                    return firstCompare != 0 ? firstCompare : a.MediaDetail.Side.CompareTo(b.MediaDetail.Side);
+                                }
+                                else if (a.MediaDetail.Number != null && a.MediaDetail.Side == null)
+                                {
+                                    return a.MediaDetail.Number.ToString().CompareTo(b.MediaDetail.Number.ToString());
+                                }
+                                else if (a.MediaDetail.Number == null && a.MediaDetail.Side != null)
+                                {
+                                    return a.MediaDetail.Side.ToString().CompareTo(b.MediaDetail.Side.ToString());
+                                }
+                                else
+                                {
+                                    return a.Name.CompareTo(b.Name);
+                                }
+                            }
+                            else
+                            {
+                                return a.Name.CompareTo(b.Name);
+                            }
+                        }
+                    );
+                    foreach (Roms.GameRomItem romItem in romItems)
+                    {
+                        string M3UFileContent = "";
+                        M3UFileContent += romItem.Name;
+                        if (romItem.MediaLabel.Length == 0)
+                        {
+                            if (romItem.RomTypeMedia.Length > 0)
+                            {
+                                M3UFileContent += "|" + romItem.RomTypeMedia;
+                            }
+                        }
+                        else
+                        {
+                            M3UFileContent += "|" + romItem.MediaLabel;
+                        }
+                        M3UFileContents.Add(M3UFileContent);
+                    }
+
+                    File.WriteAllText(Path.Combine(ZipFileTempPath, GameObject.Name + ".m3u"), String.Join(Environment.NewLine, M3UFileContents));
+
+                    // compress to zip
+                    Logging.Log(Logging.LogType.Information, "Media Group", "Compressing media group");
+                    if (!Directory.Exists(Config.LibraryConfiguration.LibraryMediaGroupDirectory))
+                    {
+                        Directory.CreateDirectory(Config.LibraryConfiguration.LibraryMediaGroupDirectory);
+                    }
+                    ZipFile.CreateFromDirectory(ZipFileTempPath, ZipFilePath, CompressionLevel.SmallestSize, false);
+
+                    // clean up
+                    if (Directory.Exists(ZipFileTempPath))
+                    {
+                        Logging.Log(Logging.LogType.Information, "Media Group", "Cleaning up");
+                        Directory.Delete(ZipFileTempPath, true);
+                    }
+
+                    // set completed
+                    dbDict["bs"] = GameRomMediaGroupItem.GroupBuildStatus.Completed;
+                    db.ExecuteCMD(sql, dbDict);
+                }
+                catch (Exception ex)
+                {
+                    // clean up
+                    if (Directory.Exists(ZipFileTempPath))
+                    {
+                        Directory.Delete(ZipFileTempPath, true);
+                    }
+
+                    if (File.Exists(ZipFilePath))
+                    {
+                        File.Delete(ZipFilePath);
+                    }
+
+                    // set failed
+                    dbDict["bs"] = GameRomMediaGroupItem.GroupBuildStatus.Failed;
+                    db.ExecuteCMD(sql, dbDict);
+
+                    Logging.Log(Logging.LogType.Critical, "Media Group", "Media Group building has failed", ex);
+                }
+            }
+        }
+
+        public class GameRomMediaGroupItem
+		{
+			public long Id { get; set; }
+			public long GameId { get; set; }
+			public long PlatformId { get; set; }
+            public string Platform {
+                get
+                {
+                    try
+                    {
+                        return Platforms.GetPlatform(PlatformId, false).Name;
+                    }
+                    catch
+                    {
+                        return "Unknown";
+                    }
+                }
+            }
+            public Models.PlatformMapping.PlatformMapItem.WebEmulatorItem? Emulator { get; set; }
+			public List<long> RomIds { get; set; }
+            public List<Roms.GameRomItem> Roms { get; set; }
+            public bool HasSaveStates { get; set; } = false;
+			private GroupBuildStatus _Status { get; set; }
+			public GroupBuildStatus Status {
+				get
+				{
+					if (_Status == GroupBuildStatus.Completed)
+					{
+						if (File.Exists(MediaGroupZipPath))
+						{
+							return GroupBuildStatus.Completed;
+						}
+						else
+						{
+							return GroupBuildStatus.NoStatus;
+						}
+					}
+					else
+					{
+						return _Status;
+					}
+				}
+                set
+                {
+                    _Status = value;
+                }
+			}
+			public long? Size {
+				get
+                {
+                    if (Status == GroupBuildStatus.Completed)
+                    {
+                        if (File.Exists(MediaGroupZipPath))
+                        {
+                            FileInfo fi = new FileInfo(MediaGroupZipPath);
+                            return fi.Length;
+                        }
+                        else
+                        {
+                            return 0;
+                        }
+                    }
+                    else
+                    {
+                        return 0;
+                    }
+                }
+			}
+			internal string MediaGroupZipPath
+			{
+				get
+				{
+					return Path.Combine(Config.LibraryConfiguration.LibraryMediaGroupDirectory, Id + ".zip");
+				}
+			}
+			public enum GroupBuildStatus
+            {
+                NoStatus = 0,
+                WaitingForBuild = 1,
+                Building = 2,
+                Completed = 3,
+                Failed = 4
+            }
+		}
+    }
+}

gaseous-server/Classes/Roms.cs

@@ -1,46 +1,89 @@
 using System;
 using System.Data;
-using gaseous_tools;
+using gaseous_signature_parser.models.RomSignatureObject;
+using static gaseous_server.Classes.RomMediaGroup;
+using gaseous_server.Classes.Metadata;
+using IGDB.Models;
 
 namespace gaseous_server.Classes
 {
 	public class Roms
 	{
-		public static List<GameRomItem> GetRoms(long GameId, long PlatformId = -1)
+		public class InvalidRomId : Exception
         { 
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            public InvalidRomId(long Id) : base("Unable to find ROM by id " + Id)
+            {}
+        }
+
+		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 + '%');
+			}
+
+			// 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) {
-				sql = "SELECT * FROM Games_Roms WHERE GameId = @id ORDER BY `Name`";
+				// data query
+				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, GameState.RomId AS SavedStateRomId FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) WHERE Games_Roms.GameId = @id" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+				
+				// count query
+				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id" + NameSearchWhere + ";";
 			} else {
-				sql = "SELECT * FROM Games_Roms WHERE GameId = @id AND PlatformId = @platformid ORDER BY `Name`";
+				// data query
+				sql = "SELECT DISTINCT Games_Roms.*, Platform.`Name` AS platformname, GameState.RomId AS SavedStateRomId FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id LEFT JOIN GameState ON (Games_Roms.Id = GameState.RomId AND GameState.UserId = @userid AND GameState.IsMediaGroup = 0) WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + " ORDER BY Platform.`Name`, Games_Roms.`Name` LIMIT 1000;";
+
+				// count query
+				sqlCount = "SELECT COUNT(Games_Roms.Id) AS RomCount FROM Games_Roms WHERE Games_Roms.GameId = @id AND Games_Roms.PlatformId = @platformid" + NameSearchWhere + ";";
+
 				dbDict.Add("platformid", PlatformId);
 			}
             DataTable romDT = db.ExecuteCMD(sql, dbDict);
+			Dictionary<string, object> rowCount = db.ExecuteCMDDict(sqlCount, dbDict)[0];
+			DataTable platformDT = db.ExecuteCMD(sqlPlatform, dbDict);
 
             if (romDT.Rows.Count > 0)
             {
-				List<GameRomItem> romItems = new List<GameRomItem>();
-				foreach (DataRow romDR in romDT.Rows)
+				// set count of roms
+				GameRoms.Count = int.Parse((string)rowCount["RomCount"]);
+
+				int pageOffset = pageSize * (pageNumber - 1);
+				for (int i = 0; i < romDT.Rows.Count; i++)
 				{
-					romItems.Add(BuildRom(romDR));
+					GameRomItem gameRomItem = BuildRom(romDT.Rows[i]);
+
+					if ((i >= pageOffset && i < pageOffset + pageSize) || pageSize == 0)
+					{
+						GameRoms.GameRomItems.Add(gameRomItem);
+					}
 				}
 
-				return romItems;
+				return GameRoms;
             }
             else
             {
-                throw new Exception("Unknown Game Id");
+                throw new Games.InvalidGameId(GameId);
             }
         }
 
 		public static GameRomItem GetRom(long RomId)
 		{
-			Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-			string sql = "SELECT * FROM Games_Roms WHERE Id = @id";
+			Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+			string sql = "SELECT Games_Roms.*, Platform.`Name` AS platformname FROM Games_Roms LEFT JOIN Platform ON Games_Roms.PlatformId = Platform.Id WHERE Games_Roms.Id = @id";
 			Dictionary<string, object> dbDict = new Dictionary<string, object>();
 			dbDict.Add("id", RomId);
 			DataTable romDT = db.ExecuteCMD(sql, dbDict);
@@ -53,7 +96,7 @@ namespace gaseous_server.Classes
 			}
 			else
 			{
-				throw new Exception("Unknown ROM Id");
+				throw new InvalidRomId(RomId);
 			}
 		}
 
@@ -65,7 +108,7 @@ namespace gaseous_server.Classes
 			// ensure metadata for gameid is present
 			IGDB.Models.Game game = Classes.Metadata.Games.GetGame(GameId, false, false, false);
 
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
             string sql = "UPDATE Games_Roms SET PlatformId=@platformid, GameId=@gameid WHERE Id = @id";
             Dictionary<string, object> dbDict = new Dictionary<string, object>();
             dbDict.Add("id", RomId);
@@ -88,8 +131,8 @@ namespace gaseous_server.Classes
 					File.Delete(rom.Path);
 				}
 
-				Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-				string sql = "DELETE FROM Games_Roms WHERE Id = @id";
+				Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+				string sql = "DELETE FROM Games_Roms WHERE Id = @id; DELETE FROM GameState WHERE RomId = @id;";
 				Dictionary<string, object> dbDict = new Dictionary<string, object>();
 				dbDict.Add("id", RomId);
 				db.ExecuteCMD(sql, dbDict);
@@ -98,25 +141,35 @@ 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;
+				}
+			}
+
 			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"],
                 Name = (string)romDR["name"],
                 Size = (long)romDR["size"],
-                CRC = ((string)romDR["crc"]).ToLower(),
-                MD5 = ((string)romDR["md5"]).ToLower(),
-                SHA1 = ((string)romDR["sha1"]).ToLower(),
+                Crc = ((string)romDR["crc"]).ToLower(),
+                Md5 = ((string)romDR["md5"]).ToLower(),
+                Sha1 = ((string)romDR["sha1"]).ToLower(),
                 DevelopmentStatus = (string)romDR["developmentstatus"],
                 Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<List<KeyValuePair<string, object>>>((string)Common.ReturnValueIfNull(romDR["attributes"], "[ ]")),
-                RomType = (int)romDR["romtype"],
+                RomType = (HasheousClient.Models.LookupResponseModel.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"])
             };
 
@@ -135,28 +188,21 @@ namespace gaseous_server.Classes
             return romItem;
         }
 
-		public class GameRomItem
+		public class GameRomObject
+		{
+			public List<GameRomItem> GameRomItems { get; set; } = new List<GameRomItem>();
+			public int Count { get; set; }
+		}
+
+		public class GameRomItem : HasheousClient.Models.LookupResponseModel.RomItem
 		{
-			public long Id { get; set; }
 			public long PlatformId { get; set; }
-			public IGDB.Models.Platform Platform { get; set; }
-			//public Dictionary<string, object>? Emulator { get; set; }
+			public string Platform { get; set; }
             public Models.PlatformMapping.PlatformMapItem.WebEmulatorItem? Emulator { get; set; }
             public long GameId { get; set; }
-			public string? Name { 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 string? MediaLabel { get; set; }
 			public string? Path { get; set; }
-            public gaseous_signature_parser.models.RomSignatureObject.RomSignatureObject.Game.Rom.SignatureSourceType Source { get; set; }
 			public string? SignatureSourceGameTitle { get; set;}
+			public bool HasSaveStates { get; set; } = false;
 			public GameLibrary.LibraryItem Library { get; set; }
         }
     }

gaseous-server/Classes/SignatureIngestors/XML.cs

@@ -1,19 +1,17 @@
 using System;
 using System.IO;
-using MySql.Data.MySqlClient;
+using gaseous_server.Classes;
 using gaseous_signature_parser.models.RomSignatureObject;
-using gaseous_tools;
-using MySqlX.XDevAPI;
 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)
         {
             // connect to database
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
 
             // process provided files
             Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Importing from " + SearchPath);
@@ -33,6 +31,14 @@ namespace gaseous_server.SignatureIngestors.XML
             {
                 string XMLFile = PathContents[i];
 
+                SetStatus(i + 1, PathContents.Length, "Processing signature file: " + XMLFile);
+
+                if (Common.SkippableFiles.Contains(Path.GetFileName(XMLFile), StringComparer.OrdinalIgnoreCase))
+                {
+                    Logging.Log(Logging.LogType.Information, "Signature Ingestor - XML", "Skipping file: " + XMLFile);
+                }
+                else
+                {
                     // check xml file md5
                     Common.hashObject hashObject = new Common.hashObject(XMLFile);
                     sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
@@ -62,6 +68,11 @@ namespace gaseous_server.SignatureIngestors.XML
                             {
                                 sql = "SELECT * FROM Signatures_Sources WHERE SourceMD5=@sourcemd5";
                                 dbDict = new Dictionary<string, object>();
+                                string sourceUriStr = "";
+                                if (Object.Url != null)
+                                {
+                                    sourceUriStr = Object.Url.ToString();
+                                }
                                 dbDict.Add("name", Common.ReturnValueIfNull(Object.Name, ""));
                                 dbDict.Add("description", Common.ReturnValueIfNull(Object.Description, ""));
                                 dbDict.Add("category", Common.ReturnValueIfNull(Object.Category, ""));
@@ -69,7 +80,7 @@ namespace gaseous_server.SignatureIngestors.XML
                                 dbDict.Add("author", Common.ReturnValueIfNull(Object.Author, ""));
                                 dbDict.Add("email", Common.ReturnValueIfNull(Object.Email, ""));
                                 dbDict.Add("homepage", Common.ReturnValueIfNull(Object.Homepage, ""));
-                            dbDict.Add("uri", Common.ReturnValueIfNull(Object.Url, ""));
+                                dbDict.Add("uri", sourceUriStr);
                                 dbDict.Add("sourcetype", Common.ReturnValueIfNull(Object.SourceType, ""));
                                 dbDict.Add("sourcemd5", Object.SourceMd5);
                                 dbDict.Add("sourcesha1", Object.SourceSHA1);
@@ -245,5 +256,7 @@ namespace gaseous_server.SignatureIngestors.XML
                     }
                 }
             }
+            ClearStatus();
+        }
     }
 }

gaseous-server/Classes/SignatureManagement.cs

@@ -1,34 +1,11 @@
-using System;
-using System.Collections.Generic;
 using System.Data;
-using System.Linq;
-using System.Security.Cryptography;
-using System.Threading.Tasks;
-using gaseous_tools;
-using Microsoft.AspNetCore.Mvc;
+using gaseous_signature_parser.models.RomSignatureObject;
 
-// For more information on enabling MVC for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
-
-namespace gaseous_server.Controllers
+namespace gaseous_server.Classes
 {
-    [ApiController]
-    [Route("api/v1/[controller]/[action]")]
-    public class SignaturesController : ControllerBase
+    public class SignatureManagement
     {
-        /// <summary>
-        /// Get the current signature counts from the database
-        /// </summary>
-        /// <returns>Number of sources, publishers, games, and rom signatures in the database</returns>
-        [HttpGet]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public Models.Signatures_Status Status()
-        {
-            return new Models.Signatures_Status();
-        }
-
-        [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)
             {
@@ -39,9 +16,7 @@ namespace gaseous_server.Controllers
             }
         }
 
-        [HttpGet]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public List<Models.Signatures_Games> GetByTosecName(string TosecName = "")
+        public List<gaseous_server.Models.Signatures_Games> GetByTosecName(string TosecName = "")
         {
             if (TosecName.Length > 0)
             {
@@ -52,29 +27,29 @@ namespace gaseous_server.Controllers
             }
         }
 
-        private List<Models.Signatures_Games> _GetSignature(string sqlWhere, string searchString)
+        private List<gaseous_server.Models.Signatures_Games> _GetSignature(string sqlWhere, string searchString)
         {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            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<Models.Signatures_Games> GamesList = new List<Models.Signatures_Games>();
+            List<gaseous_server.Models.Signatures_Games> GamesList = new List<gaseous_server.Models.Signatures_Games>();
 
             foreach (DataRow sigDbRow in sigDb.Rows)
             {
-                Models.Signatures_Games gameItem = new Models.Signatures_Games
+                gaseous_server.Models.Signatures_Games gameItem = new gaseous_server.Models.Signatures_Games
                 {
-                    Game = new Models.Signatures_Games.GameItem
+                    Game = new gaseous_server.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"],
+                        Demo = (gaseous_server.Models.Signatures_Games.GameItem.DemoTypes)(int)sigDbRow["Demo"],
                         System = (string)sigDbRow["Platform"],
                         SystemVariant = (string)sigDbRow["SystemVariant"],
                         Video = (string)sigDbRow["Video"],
@@ -82,7 +57,7 @@ namespace gaseous_server.Controllers
                         Language = (string)sigDbRow["Language"],
                         Copyright = (string)sigDbRow["Copyright"]
                     },
-                    Rom = new Models.Signatures_Games.RomItem
+                    Rom = new gaseous_server.Models.Signatures_Games.RomItem
                     {
                         Id = (Int32)sigDbRow["romid"],
                         Name = (string)sigDbRow["romname"],
@@ -92,10 +67,10 @@ namespace gaseous_server.Controllers
                         Sha1 = ((string)sigDbRow["SHA1"]).ToLower(),
                         DevelopmentStatus = (string)sigDbRow["DevelopmentStatus"],
                         Attributes = Newtonsoft.Json.JsonConvert.DeserializeObject<List<KeyValuePair<string, object>>>((string)Common.ReturnValueIfNull(sigDbRow["Attributes"], "[]")),
-                        RomType = (Models.Signatures_Games.RomItem.RomTypes)(int)sigDbRow["RomType"],
+                        RomType = (gaseous_server.Models.Signatures_Games.RomItem.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"]
+                        SignatureSource = (gaseous_server.Models.Signatures_Games.RomItem.SignatureSourceType)(Int32)sigDbRow["MetadataSource"]
                     }
                 };
                 GamesList.Add(gameItem);
@@ -104,4 +79,3 @@ namespace gaseous_server.Controllers
         }
     }
 }
-

gaseous-server/Classes/Statistics.cs

@@ -0,0 +1,99 @@
+using System.Data;
+using gaseous_server.Models;
+
+namespace gaseous_server.Classes
+{
+    public class Statistics
+    {
+        public StatisticsModel RecordSession(Guid SessionId, long GameId, string UserId)
+        {
+            Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
+            string sql;
+            Dictionary<string, object> dbDict;
+
+            if (SessionId == Guid.Empty)
+            {
+                // new session required
+                SessionId = Guid.NewGuid();
+
+                sql = "INSERT INTO UserTimeTracking (GameId, UserId, SessionId, SessionTime, SessionLength) VALUES (@gameid, @userid, @sessionid, @sessiontime, @sessionlength);";
+                dbDict = new Dictionary<string, object>{
+                    { "gameid", GameId },
+                    { "userid", UserId },
+                    { "sessionid", SessionId },
+                    { "sessiontime", DateTime.UtcNow },
+                    { "sessionlength", 1 }
+                };
+
+                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/Controllers/CollectionsController.cs

@@ -1,228 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO.Compression;
-using System.Linq;
-using System.Threading.Tasks;
-using gaseous_server.Classes;
-using Microsoft.AspNetCore.Mvc;
-
-namespace gaseous_server.Controllers
-{
-    [ApiController]
-    [Route("api/v1/[controller]")]
-    public class CollectionsController : Controller
-    {
-        /// <summary>
-        /// Gets all ROM collections
-        /// </summary>
-        /// <returns></returns>
-        [HttpGet]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public List<Classes.Collections.CollectionItem> GetCollections()
-        {
-            return Classes.Collections.GetCollections();
-        }
-
-        /// <summary>
-        /// Gets a specific ROM collection
-        /// </summary>
-        /// <param name="CollectionId"></param>
-        /// <param name="Build">Set to true to begin the collection build process</param>
-        /// <returns></returns>
-        [HttpGet]
-        [Route("{CollectionId}")]
-        [ProducesResponseType(typeof(Classes.Collections.CollectionItem), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollection(long CollectionId, bool Build = false)
-        {
-            try
-            {
-                if (Build == true)
-                {
-                    Classes.Collections.StartCollectionItemBuild(CollectionId);
-                }
-
-                return Ok(Classes.Collections.GetCollection(CollectionId));
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
-
-        /// <summary>
-        /// Gets the contents of the specified ROM collection
-        /// </summary>
-        /// <param name="CollectionId"></param>
-        /// <returns></returns>
-        [HttpGet]
-        [Route("{CollectionId}/Roms")]
-        [ProducesResponseType(typeof(List<Classes.Collections.CollectionContents.CollectionPlatformItem>), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollectionRoms(long CollectionId)
-        {
-            try
-            {
-                Classes.Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId);
-                return Ok(Classes.Collections.GetCollectionContent(collectionItem));
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
-
-        /// <summary>
-        /// Gets a preview of the provided collection item
-        /// </summary>
-        /// <param name="Item"></param>
-        /// <returns></returns>
-        [HttpPost]
-        [Route("Preview")]
-        [ProducesResponseType(typeof(List<Classes.Collections.CollectionContents.CollectionPlatformItem>), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollectionRomsPreview(Classes.Collections.CollectionItem Item)
-        {
-            try
-            {
-                return Ok(Classes.Collections.GetCollectionContent(Item));
-            }
-            catch (Exception ex)
-            {
-               return NotFound(ex);
-            }
-        }
-
-        /// <summary>
-        /// Gets ROM collection in zip format
-        /// </summary>
-        /// <param name="CollectionId"></param>
-        /// <returns></returns>
-        [HttpGet]
-        [Route("{CollectionId}/Roms/Zip")]
-        [ProducesResponseType(typeof(FileStreamResult), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult GetCollectionRomsZip(long CollectionId)
-        {
-            try
-            {
-                Classes.Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId);
-
-                string ZipFilePath = Path.Combine(gaseous_tools.Config.LibraryConfiguration.LibraryCollectionsDirectory, CollectionId + ".zip");
-
-                if (System.IO.File.Exists(ZipFilePath))
-                {
-                    var stream = new FileStream(ZipFilePath, FileMode.Open);
-                    return File(stream, "application/zip", collectionItem.Name + ".zip");
-                }
-                else
-                {
-                    return NotFound();
-                }
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
-
-        /// <summary>
-        /// Creates a new ROM collection
-        /// </summary>
-        /// <param name="Item"></param>
-        /// <returns></returns>
-        [HttpPost]
-        [ProducesResponseType(typeof(Classes.Collections.CollectionItem), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        public ActionResult NewCollection(Classes.Collections.CollectionItem Item)
-        {
-            try
-            {
-                return Ok(Classes.Collections.NewCollection(Item));
-            }
-            catch (Exception ex)
-            {
-                return BadRequest(ex);
-            }
-        }
-
-        /// <summary>
-        /// Edits an existing collection
-        /// </summary>
-        /// <param name="CollectionId"></param>
-        /// <param name="Item"></param>
-        /// <returns></returns>
-        [HttpPatch]
-        [Route("{CollectionId}")]
-        [ProducesResponseType(typeof(Classes.Collections.CollectionItem), StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult EditCollection(long CollectionId, Classes.Collections.CollectionItem Item)
-        {
-            try
-            {
-                return Ok(Classes.Collections.EditCollection(CollectionId, Item, true));
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
-
-        /// <summary>
-        /// Edits an existing collection
-        /// </summary>
-        /// <param name="CollectionId"></param>
-        /// <param name="Item"></param>
-        /// <returns></returns>
-        [HttpPatch]
-        [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)
-        {
-            try
-            {
-                Collections.CollectionItem collectionItem = Classes.Collections.GetCollection(CollectionId);
-                bool ItemFound = false;
-                foreach (Collections.CollectionItem.AlwaysIncludeItem includeItem in collectionItem.AlwaysInclude)
-                {
-                    if (includeItem.PlatformId == Inclusion.PlatformId && includeItem.GameId == Inclusion.GameId)
-                    {
-                        ItemFound = true;
-                    }
-                }
-                if (ItemFound == false)
-                {
-                    collectionItem.AlwaysInclude.Add(Inclusion);
-                }
-
-                return Ok(Classes.Collections.EditCollection(CollectionId, collectionItem, Rebuild));
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
-
-        /// <summary>
-        /// Deletes the specified ROM collection
-        /// </summary>
-        /// <param name="CollectionId"></param>
-        [HttpDelete]
-        [Route("{CollectionId}")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public ActionResult DeleteCollection(long CollectionId)
-        {
-            try
-            {
-                Classes.Collections.DeleteCollection(CollectionId);
-                return Ok();
-            }
-            catch
-            {
-                return NotFound();
-            }
-        }
-    }
-}

gaseous-server/Controllers/FilterController.cs

@@ -1,84 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
-using gaseous_tools;
-using IGDB.Models;
-using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Mvc;
-
-namespace gaseous_server.Controllers
-{
-    [Route("api/v1/[controller]")]
-    [ApiController]
-    public class FilterController : ControllerBase
-    {
-        [HttpGet]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        //[ResponseCache(CacheProfileName = "5Minute")]
-        public Dictionary<string, object> Filter()
-        {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-            Dictionary<string, object> FilterSet = new Dictionary<string, object>();
-
-            // platforms
-            List<Platform> platforms = new List<Platform>();
-            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`";
-            DataTable dbResponse = db.ExecuteCMD(sql);
-
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                platforms.Add(Classes.Metadata.Platforms.GetPlatform((long)dr["id"]));
-            }
-            FilterSet.Add("platforms", platforms);
-
-            // genres
-            List<Genre> genres = new List<Genre>();
-            sql = "SELECT DISTINCT t1.Id, t1.`Name` FROM Genre AS t1 JOIN (SELECT * FROM Game WHERE (SELECT COUNT(Id) FROM Games_Roms WHERE GameId = Game.Id) > 0) AS t2 ON JSON_CONTAINS(t2.Genres, CAST(t1.Id AS char), '$') ORDER BY t1.`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 t1.Id, t1.`Name` FROM GameMode AS t1 JOIN (SELECT * FROM Game WHERE (SELECT COUNT(Id) FROM Games_Roms WHERE GameId = Game.Id) > 0) AS t2 ON JSON_CONTAINS(t2.GameModes, CAST(t1.Id AS char), '$') ORDER BY t1.Id";
-            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 t1.Id, t1.`Name` FROM PlayerPerspective AS t1 JOIN (SELECT * FROM Game WHERE (SELECT COUNT(Id) FROM Games_Roms WHERE GameId = Game.Id) > 0) AS t2 ON JSON_CONTAINS(t2.PlayerPerspectives, CAST(t1.Id AS char), '$') ORDER BY t1.`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 t1.Id, t1.`Name` FROM Theme AS t1 JOIN (SELECT * FROM Game WHERE (SELECT COUNT(Id) FROM Games_Roms WHERE GameId = Game.Id) > 0) AS t2 ON JSON_CONTAINS(t2.Themes, CAST(t1.Id AS char), '$') ORDER BY t1.`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;
-        }
-    }
-}

gaseous-server/Controllers/LogsController.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using gaseous_tools;
-using Microsoft.AspNetCore.Mvc;
-
-namespace gaseous_server.Controllers
-{
-    [ApiController]
-    [Route("api/v1/[controller]")]
-    public class LogsController : Controller
-    {
-        [HttpGet]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public List<Logging.LogItem> Logs(long? StartIndex, int PageNumber = 1, int PageSize = 100)
-        {
-            return Logging.GetLogs(StartIndex, PageNumber, PageSize);
-        }
-    }
-}

gaseous-server/Controllers/SearchController.cs

@@ -1,68 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using gaseous_tools;
-using IGDB;
-using IGDB.Models;
-using Microsoft.AspNetCore.Mvc;
-using static gaseous_server.Classes.Metadata.Games;
-using static gaseous_tools.Config.ConfigFile;
-
-namespace gaseous_server.Controllers
-{
-    [ApiController]
-    [Route("api/v1/[controller]")]
-    public class SearchController : Controller
-    {
-        private static IGDBClient igdb = new IGDBClient(
-                            // Found in Twitch Developer portal for your app
-                            Config.IGDB.ClientId,
-                            Config.IGDB.Secret
-                        );
-
-        [HttpGet]
-        [Route("Platform")]
-        [ProducesResponseType(typeof(List<Platform>), StatusCodes.Status200OK)]
-        public async Task<ActionResult> SearchPlatform(string SearchString)
-        {
-            List<Platform> RetVal = await _SearchForPlatform(SearchString);
-            return Ok(RetVal);
-        }
-
-        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; ";
-            searchBody += "where name ~ *\"" + SearchString + "\"*;";
-
-            // get Platform metadata
-            var results = await igdb.QueryAsync<Platform>(IGDBClient.Endpoints.Platforms, query: searchBody);
-
-            return results.ToList();
-        }
-
-        [HttpGet]
-        [Route("Game")]
-        [ProducesResponseType(typeof(List<Game>), StatusCodes.Status200OK)]
-        public async Task<ActionResult> SearchGame(long PlatformId, string SearchString)
-        {
-            List<Game> RetVal = await _SearchForGame(PlatformId, SearchString);
-            return Ok(RetVal);
-        }
-
-        private static async Task<List<Game>> _SearchForGame(long PlatformId, string SearchString)
-        {
-            string searchBody = "";
-            searchBody += "fields cover.*,first_release_date,name,platforms,slug; ";
-            searchBody += "search \"" + SearchString + "\";";
-            searchBody += "where platforms = (" + PlatformId + ");";
-
-            // get Platform metadata
-            var results = await igdb.QueryAsync<Game>(IGDBClient.Endpoints.Games, query: searchBody);
-
-            return results.ToList();
-        }
-    }
-}
-

gaseous-server/Controllers/SystemController.cs

@@ -1,114 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
-using gaseous_tools;
-using Microsoft.AspNetCore.Mvc;
-
-namespace gaseous_server.Controllers
-{
-    [ApiController]
-    [Route("api/v1/[controller]")]
-    public class SystemController : Controller
-    {
-        [HttpGet]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public SystemInfo GetSystemStatus()
-        {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-
-            SystemInfo ReturnValue = new SystemInfo();
-
-            // disk size
-            List<SystemInfo.PathItem> Disks = new List<SystemInfo.PathItem>();
-            foreach (GameLibrary.LibraryItem libraryItem in GameLibrary.GetLibraries)
-            {
-                Disks.Add(GetDisk(libraryItem.Path));
-            }
-            ReturnValue.Paths = Disks;
-
-            // database size
-            string sql = "SELECT table_schema, SUM(data_length + index_length) FROM information_schema.tables WHERE table_schema = '" + Config.DatabaseConfiguration.DatabaseName + "'";
-            DataTable dbResponse = db.ExecuteCMD(sql);
-            ReturnValue.DatabaseSize = (long)(System.Decimal)dbResponse.Rows[0][1];
-
-            // platform statistics
-            sql = "SELECT Platform.`name`, grc.Count, grs.Size FROM Platform INNER JOIN (SELECT Platform.`name` AS `Name`, SUM(grs.Size) AS Size FROM Platform JOIN Games_Roms AS grs ON (grs.PlatformId = Platform.Id) GROUP BY Platform.`name`) grs ON (grs.`Name` = Platform.`name`) INNER JOIN (SELECT Platform.`name` AS `Name`, COUNT(grc.Size) AS Count FROM Platform JOIN Games_Roms AS grc ON (grc.PlatformId = Platform.Id) GROUP BY Platform.`name`) grc ON (grc.`Name` = Platform.`name`) ORDER BY Platform.`name`;";
-            dbResponse = db.ExecuteCMD(sql);
-            ReturnValue.PlatformStatistics = new List<SystemInfo.PlatformStatisticsItem>();
-            foreach (DataRow dr in dbResponse.Rows)
-            {
-                SystemInfo.PlatformStatisticsItem platformStatisticsItem = new SystemInfo.PlatformStatisticsItem
-                {
-                    Platform = (string)dr["name"],
-                    RomCount = (long)dr["Count"],
-                    TotalSize = (long)(System.Decimal)dr["Size"]
-                };
-                ReturnValue.PlatformStatistics.Add(platformStatisticsItem);
-            }
-
-            return ReturnValue;
-        }
-
-        [HttpGet]
-        [Route("Version")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public Version GetSystemVersion() {
-            return Assembly.GetExecutingAssembly().GetName().Version;
-        }
-
-        [HttpGet]
-        [Route("VersionFile")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
-        public FileContentResult GetSystemVersionAsFile() {
-            Database db = new gaseous_tools.Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
-            string ver = "var AppVersion = \"" + Assembly.GetExecutingAssembly().GetName().Version.ToString() + "\";" + Environment.NewLine +
-                "var DBSchemaVersion = \"" + db.GetDatabaseSchemaVersion() + "\";";
-            byte[] bytes = Encoding.UTF8.GetBytes(ver);
-            return File(bytes, "text/javascript");
-        }
-
-        private SystemInfo.PathItem GetDisk(string Path)
-        {
-            SystemInfo.PathItem pathItem = new SystemInfo.PathItem {
-                LibraryPath = Path,
-                SpaceUsed = gaseous_tools.Common.DirSize(new DirectoryInfo(Path)),
-                SpaceAvailable = new DriveInfo(Path).AvailableFreeSpace,
-                TotalSpace = new DriveInfo(Path).TotalSize
-            };
-
-            return pathItem;
-        }
-
-        public class SystemInfo
-        {
-            public Version ApplicationVersion { 
-                get
-                    {
-                        return Assembly.GetExecutingAssembly().GetName().Version;
-                    }
-            }
-            public List<PathItem>? Paths { get; set; }
-            public long DatabaseSize { get; set; }
-            public List<PlatformStatisticsItem>? PlatformStatistics { get; set; }
-
-            public class PathItem
-            {
-                public string LibraryPath { get; set; }
-                public long SpaceUsed { get; set; }
-                public long SpaceAvailable { get; set; }
-                public long TotalSpace { get; set; }
-            }
-
-            public class PlatformStatisticsItem
-            {
-                public string Platform { get; set; }
-                public long RomCount { get; set; }
-                public long TotalSize { get; set; }
-            }
-        }
-    }
-}

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

@@ -0,0 +1,531 @@
+using System.Data;
+using System.Security.Claims;
+using System.Text;
+using Authentication;
+using gaseous_server.Classes;
+using Microsoft.AspNetCore.Authorization;
+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
+{
+    [ApiController]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiVersion("1.0")]
+    [ApiVersion("1.1")]
+    [Authorize]
+    public class AccountController : Controller
+    {
+        private readonly UserManager<ApplicationUser> _userManager;
+        private readonly SignInManager<ApplicationUser> _signInManager;
+        private readonly IEmailSender _emailSender;
+        private readonly ILogger _logger;
+
+        public AccountController(
+            UserManager<ApplicationUser> userManager,
+            SignInManager<ApplicationUser> signInManager,
+            IEmailSender emailSender,
+            ILoggerFactory loggerFactory)
+        {
+            _userManager = userManager;
+            _signInManager = signInManager;
+            _emailSender = emailSender;
+            _logger = loggerFactory.CreateLogger<AccountController>();
+        }
+
+        [HttpPost]
+        [AllowAnonymous]
+        [Route("Login")]
+        public async Task<IActionResult> Login(LoginViewModel model)
+        {
+            if (ModelState.IsValid)
+            {
+                // This doesn't count login failures towards account lockout
+                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
+                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
+                if (result.Succeeded)
+                {
+                    Logging.Log(Logging.LogType.Information, "Login", model.Email + " has logged in, from IP: " + HttpContext.Connection.RemoteIpAddress?.ToString());
+                    return Ok(result.ToString());
+                }
+                // if (result.RequiresTwoFactor)
+                // {
+                //     return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
+                // }
+                if (result.IsLockedOut)
+                {
+                    Logging.Log(Logging.LogType.Warning, "Login", model.Email + " was unable to login due to a locked account. Login attempt from IP: " + HttpContext.Connection.RemoteIpAddress?.ToString());
+                    return Unauthorized();
+                }
+                else
+                {
+                    Logging.Log(Logging.LogType.Critical, "Login", "An unknown error occurred during login by " + model.Email + ". Login attempt from IP: " + HttpContext.Connection.RemoteIpAddress?.ToString());
+                    return Unauthorized();
+                }
+            }
+
+            // If we got this far, something failed, redisplay form
+            Logging.Log(Logging.LogType.Critical, "Login", "An unknown error occurred during login by " + model.Email + ". Login attempt from IP: " + HttpContext.Connection.RemoteIpAddress?.ToString());
+            return Unauthorized();
+        }
+
+        [HttpPost]
+        [Route("LogOff")]
+        public async Task<IActionResult> LogOff()
+        {
+            var userName = User.FindFirstValue(ClaimTypes.Name);
+            await _signInManager.SignOutAsync();
+            if (userName != null)
+            {
+                Logging.Log(Logging.LogType.Information, "Login", userName + " has logged out");
+            }
+            return Ok();
+        }
+
+        [HttpGet]
+        [Route("Profile/Basic")]
+        [Authorize]
+        public async Task<IActionResult> ProfileBasic()
+        {
+            ProfileBasicViewModel profile = new ProfileBasicViewModel();
+            profile.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+            ApplicationUser user = await _userManager.FindByIdAsync(profile.UserId);
+            profile.UserName = _userManager.GetUserName(HttpContext.User);
+            profile.EmailAddress = await _userManager.GetEmailAsync(user);
+            profile.Roles = new List<string>(await _userManager.GetRolesAsync(user));
+            profile.SecurityProfile = user.SecurityProfile;
+            profile.UserPreferences = user.UserPreferences;
+            profile.Avatar = user.Avatar;
+            profile.Roles.Sort();
+
+            return Ok(profile);
+        }
+
+        [HttpGet]
+        [Route("Profile/Basic/profile.js")]
+        [ApiExplorerSettings(IgnoreApi = true)]
+        [AllowAnonymous]
+        public async Task<IActionResult> ProfileBasicFile()
+        {
+            var user = await _userManager.GetUserAsync(User);
+            if (user != null)
+            {
+                ProfileBasicViewModel profile = new ProfileBasicViewModel();
+                profile.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
+                profile.UserName = _userManager.GetUserName(HttpContext.User);
+                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) + ";";
+
+                byte[] bytes = Encoding.UTF8.GetBytes(profileString);
+                return File(bytes, "text/javascript");
+            }
+            else
+            {
+                string profileString = "var userProfile = null;";
+
+                byte[] bytes = Encoding.UTF8.GetBytes(profileString);
+                return File(bytes, "text/javascript");
+            }
+        }
+
+        [HttpPost]
+        [Route("ChangePassword")]
+        [Authorize]
+        public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model)
+        {
+            if (ModelState.IsValid)
+            {
+                var user = await _userManager.GetUserAsync(User);
+                if (user == null)
+                {
+                    return RedirectToAction("Login");
+                }
+
+                // ChangePasswordAsync changes the user password
+                var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
+
+                // The new password did not meet the complexity rules or
+                // the current password is incorrect. Add these errors to
+                // the ModelState and rerender ChangePassword view
+                if (!result.Succeeded)
+                {
+                    foreach (var error in result.Errors)
+                    {
+                        ModelState.AddModelError(string.Empty, error.Description);
+                    }
+                    return Unauthorized(result);
+                }
+
+                // Upon successfully changing the password refresh sign-in cookie
+                await _signInManager.RefreshSignInAsync(user);
+                return Ok();
+            }
+
+            return NotFound();
+        }
+
+        [HttpGet]
+        [Route("Users")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> GetAllUsers()
+        {
+            List<UserViewModel> users = new List<UserViewModel>();
+
+            foreach (ApplicationUser rawUser in _userManager.Users)
+            {
+                UserViewModel user = new UserViewModel();
+                user.Id = rawUser.Id;
+                user.EmailAddress = rawUser.NormalizedEmail.ToLower();
+                user.LockoutEnabled = rawUser.LockoutEnabled;
+                user.LockoutEnd = rawUser.LockoutEnd;
+                user.SecurityProfile = rawUser.SecurityProfile;
+                user.Avatar = rawUser.Avatar;
+                
+                // get roles
+                ApplicationUser? aUser = await _userManager.FindByIdAsync(rawUser.Id);
+                if (aUser != null)
+                {
+                    IList<string> aUserRoles = await _userManager.GetRolesAsync(aUser);
+                    user.Roles = aUserRoles.ToList();
+
+                    user.Roles.Sort();
+                }
+
+                users.Add(user);
+            }
+
+            return Ok(users);
+        }
+
+        [HttpPost]
+        [Route("Users")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> NewUser(RegisterViewModel model)
+        {
+            if (ModelState.IsValid)
+            {
+                ApplicationUser user = new ApplicationUser
+                { 
+                    UserName = model.UserName, 
+                    NormalizedUserName = model.UserName.ToUpper(),
+                    Email = model.Email,
+                    NormalizedEmail = model.Email.ToUpper()
+                };
+                var result = await _userManager.CreateAsync(user, model.Password);
+                if (result.Succeeded)
+                {
+                    // add new users to the player role
+                    await _userManager.AddToRoleAsync(user, "Player");
+
+                    Logging.Log(Logging.LogType.Information, "User Management", User.FindFirstValue(ClaimTypes.Name) + " created user " + model.Email + " with password.");
+
+                    return Ok(result);
+                }
+                else
+                {
+                    return Ok(result);
+                }
+            }   
+            else
+            {
+                return NotFound();
+            }
+        }
+
+        [HttpGet]
+        [Route("Users/{UserId}")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> GetUser(string UserId)
+        {
+            ApplicationUser? rawUser = await _userManager.FindByIdAsync(UserId);
+            
+            if (rawUser != null)
+            {
+                UserViewModel user = new UserViewModel();
+                user.Id = rawUser.Id;
+                user.EmailAddress = rawUser.NormalizedEmail.ToLower();
+                user.LockoutEnabled = rawUser.LockoutEnabled;
+                user.LockoutEnd = rawUser.LockoutEnd;
+                user.SecurityProfile = rawUser.SecurityProfile;
+                
+                // get roles
+                IList<string> aUserRoles = await _userManager.GetRolesAsync(rawUser);
+                user.Roles = aUserRoles.ToList();
+
+                user.Roles.Sort();
+
+                return Ok(user);
+            }
+            else
+            {
+                return NotFound();
+            }
+        }
+
+        [HttpDelete]
+        [Route("Users/{UserId}")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> DeleteUser(string UserId)
+        {
+            // get user
+            ApplicationUser? user = await _userManager.FindByIdAsync(UserId);
+
+            if (user == null)
+            {
+                return NotFound();
+            }
+            else
+            {
+                await _userManager.DeleteAsync(user);
+                Logging.Log(Logging.LogType.Information, "User Management", User.FindFirstValue(ClaimTypes.Name) + " deleted user " + user.Email);
+                return Ok();
+            }
+        }
+
+        [HttpPost]
+        [Route("Users/{UserId}/Roles")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> SetUserRoles(string UserId, string RoleName)
+        {
+            ApplicationUser? user = await _userManager.FindByIdAsync(UserId);
+            
+            if (user != null)
+            {
+                // get roles
+                List<string> userRoles = (await _userManager.GetRolesAsync(user)).ToList();
+                
+                // delete all roles
+                foreach (string role in userRoles)
+                {
+                    if ((new string[] { "Admin", "Gamer", "Player" }).Contains(role) )
+                    {
+                        await _userManager.RemoveFromRoleAsync(user, role);
+                    }
+                }
+
+                // add only requested roles
+                switch (RoleName)
+                {
+                    case "Admin":
+                        await _userManager.AddToRoleAsync(user, "Admin");
+                        await _userManager.AddToRoleAsync(user, "Gamer");
+                        await _userManager.AddToRoleAsync(user, "Player");
+                        break;
+                    case "Gamer":
+                        await _userManager.AddToRoleAsync(user, "Gamer");
+                        await _userManager.AddToRoleAsync(user, "Player");
+                        break;
+                    case "Player":
+                        await _userManager.AddToRoleAsync(user, "Player");
+                        break;
+                    default:
+                        await _userManager.AddToRoleAsync(user, RoleName);
+                        break;
+                }
+                
+                return Ok();
+            }
+            else
+            {
+                return NotFound();
+            }
+        }
+
+        [HttpPost]
+        [Route("Users/{UserId}/SecurityProfile")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> SetUserSecurityProfile(string UserId, SecurityProfileViewModel securityProfile)
+        {
+            if (ModelState.IsValid)
+            {
+                ApplicationUser? user = await _userManager.FindByIdAsync(UserId);
+                
+                if (user != null)
+                {
+                    user.SecurityProfile = securityProfile;
+                    await _userManager.UpdateAsync(user);
+                    
+                    return Ok();
+                }
+                else
+                {
+                    return NotFound();
+                }
+            }
+            else
+            {
+                return NotFound();
+            }
+        }
+
+        [HttpPost]
+        [Route("Users/{UserId}/Password")]
+        [Authorize(Roles = "Admin")]
+        public async Task<IActionResult> ResetPassword(string UserId, SetPasswordViewModel model)
+        {
+            if (ModelState.IsValid)
+            {
+                // we can reset the users password
+                ApplicationUser? user = await _userManager.FindByIdAsync(UserId);
+                if (user != null)
+                {
+                    string resetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
+                    IdentityResult passwordChangeResult = await _userManager.ResetPasswordAsync(user, resetToken, model.NewPassword);
+                    if (passwordChangeResult.Succeeded == true)
+                    {
+                        return Ok(passwordChangeResult);
+                    }
+                    else
+                    {
+                        return Ok(passwordChangeResult);
+                    }
+                }
+                else
+                {
+                    return NotFound();
+                }
+            }
+            else
+            {
+                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

@@ -2,14 +2,21 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Asp.Versioning;
 
 namespace gaseous_server.Controllers
 {
     [ApiController]
-    [Route("api/v1/[controller]")]
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [ApiVersion("1.0")]
+    [ApiVersion("1.1")]
+    [Authorize(Roles = "Admin,Gamer,Player")]
     public class BackgroundTasksController : Controller
     {
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
         [HttpGet]
         [ProducesResponseType(StatusCodes.Status200OK)]
         public List<ProcessQueue.QueueItem> GetQueue()
@@ -17,10 +24,13 @@ namespace gaseous_server.Controllers
             return ProcessQueue.QueueItems;
         }
 
+        [MapToApiVersion("1.0")]
+        [MapToApiVersion("1.1")]
         [HttpGet]
         [Route("{TaskType}")]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Roles = "Admin")]
         public ActionResult<ProcessQueue.QueueItem> ForceRun(ProcessQueue.QueueItemType TaskType, Boolean ForceRun)
         {
             foreach (ProcessQueue.QueueItem qi in ProcessQueue.QueueItems)