Project Types, Code Cleanup, and Rename Mods -> Projects (#192)

* Initial work for modpacks and project types

* Code cleanup, fix some issues

* Username route getting, remove pointless tests

* Base validator types + fixes

* Fix strange IML generation

* Multiple hash requests for version files

* Fix docker build (hopefully)

* Legacy routes

* Finish validator architecture

* Update rust version in dockerfile

* Added caching and fixed typo (#203)

* Added caching and fixed typo

* Fixed clippy error

* Removed log for cache

* Add final validators, fix how loaders are handled and add icons to tags

* Fix search module

* Fix parts of legacy API not working

Co-authored-by: Redblueflame <contact@redblueflame.com>

src/validate/fabric.rs

@@ -0,0 +1,48 @@
+use crate::validate::{SupportedGameVersions, ValidationError, ValidationResult};
+use chrono::{DateTime, NaiveDateTime, Utc};
+use std::io::Cursor;
+use zip::ZipArchive;
+
+pub struct FabricValidator {}
+
+impl super::Validator for FabricValidator {
+    fn get_file_extensions<'a>(&self) -> &'a [&'a str] {
+        &["jar", "zip"]
+    }
+
+    fn get_project_types<'a>(&self) -> &'a [&'a str] {
+        &["mod"]
+    }
+
+    fn get_supported_loaders<'a>(&self) -> &'a [&'a str] {
+        &["fabric"]
+    }
+
+    fn get_supported_game_versions(&self) -> SupportedGameVersions {
+        // Time since release of 18w49a, the first fabric version
+        SupportedGameVersions::PastDate(DateTime::<Utc>::from_utc(
+            NaiveDateTime::from_timestamp(1543969469, 0),
+            Utc,
+        ))
+    }
+
+    fn validate(
+        &self,
+        archive: &mut ZipArchive<Cursor<&[u8]>>,
+    ) -> Result<ValidationResult, ValidationError> {
+        archive.by_name("fabric.mod.json")?;
+
+        if !archive
+            .file_names()
+            .any(|name| name.ends_with("refmap.json") || name.ends_with(".class"))
+        {
+            return Ok(ValidationResult::Warning(
+                "Fabric mod file is a source file!".to_string(),
+            ));
+        }
+
+        //TODO: Check if file is a dev JAR?
+
+        Ok(ValidationResult::Pass)
+    }
+}

src/validate/forge.rs

@@ -0,0 +1,86 @@
+use crate::validate::{SupportedGameVersions, ValidationError, ValidationResult};
+use chrono::{DateTime, NaiveDateTime, Utc};
+use std::io::Cursor;
+use zip::ZipArchive;
+
+pub struct ForgeValidator {}
+
+impl super::Validator for ForgeValidator {
+    fn get_file_extensions<'a>(&self) -> &'a [&'a str] {
+        &["jar", "zip"]
+    }
+
+    fn get_project_types<'a>(&self) -> &'a [&'a str] {
+        &["mod"]
+    }
+
+    fn get_supported_loaders<'a>(&self) -> &'a [&'a str] {
+        &["forge"]
+    }
+
+    fn get_supported_game_versions(&self) -> SupportedGameVersions {
+        // Time since release of 1.13, the first forge version which uses the new TOML system
+        SupportedGameVersions::PastDate(DateTime::<Utc>::from_utc(
+            NaiveDateTime::from_timestamp(1540122067, 0),
+            Utc,
+        ))
+    }
+
+    fn validate(
+        &self,
+        archive: &mut ZipArchive<Cursor<&[u8]>>,
+    ) -> Result<ValidationResult, ValidationError> {
+        archive.by_name("META-INF/mods.toml")?;
+
+        if !archive.file_names().any(|name| name.ends_with(".class")) {
+            return Ok(ValidationResult::Warning(
+                "Forge mod file is a source file!".to_string(),
+            ));
+        }
+
+        //TODO: Check if file is a dev JAR?
+
+        Ok(ValidationResult::Pass)
+    }
+}
+
+pub struct LegacyForgeValidator {}
+
+impl super::Validator for LegacyForgeValidator {
+    fn get_file_extensions<'a>(&self) -> &'a [&'a str] {
+        &["jar", "zip"]
+    }
+
+    fn get_project_types<'a>(&self) -> &'a [&'a str] {
+        &["mod"]
+    }
+
+    fn get_supported_loaders<'a>(&self) -> &'a [&'a str] {
+        &["forge"]
+    }
+
+    fn get_supported_game_versions(&self) -> SupportedGameVersions {
+        // Times between versions 1.5.2 to 1.12.2, which all use the legacy way of defining mods
+        SupportedGameVersions::Range(
+            DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(1366818300, 0), Utc),
+            DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(1505810340, 0), Utc),
+        )
+    }
+
+    fn validate(
+        &self,
+        archive: &mut ZipArchive<Cursor<&[u8]>>,
+    ) -> Result<ValidationResult, ValidationError> {
+        archive.by_name("mcmod.info")?;
+
+        if !archive.file_names().any(|name| name.ends_with(".class")) {
+            return Ok(ValidationResult::Warning(
+                "Forge mod file is a source file!".to_string(),
+            ));
+        }
+
+        //TODO: Check if file is a dev JAR?
+
+        Ok(ValidationResult::Pass)
+    }
+}

src/validate/mod.rs

@@ -0,0 +1,117 @@
+use crate::models::projects::{GameVersion, Loader};
+use crate::validate::fabric::FabricValidator;
+use crate::validate::forge::{ForgeValidator, LegacyForgeValidator};
+use crate::validate::pack::PackValidator;
+use chrono::{DateTime, Utc};
+use std::io::Cursor;
+use thiserror::Error;
+use zip::ZipArchive;
+
+mod fabric;
+mod forge;
+mod pack;
+
+#[derive(Error, Debug)]
+pub enum ValidationError {
+    #[error("Unable to read Zip Archive: {0}")]
+    ZipError(#[from] zip::result::ZipError),
+    #[error("IO Error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Error while validating JSON: {0}")]
+    SerDeError(#[from] serde_json::Error),
+    #[error("Invalid Input: {0}")]
+    InvalidInputError(String),
+}
+
+#[derive(Eq, PartialEq)]
+pub enum ValidationResult {
+    /// File should be marked as primary
+    Pass,
+    /// File should not be marked primary, the reason for which is inside the String
+    Warning(String),
+}
+
+pub enum SupportedGameVersions {
+    All,
+    PastDate(DateTime<Utc>),
+    Range(DateTime<Utc>, DateTime<Utc>),
+    Custom(Vec<GameVersion>),
+}
+
+pub trait Validator: Sync {
+    fn get_file_extensions<'a>(&self) -> &'a [&'a str];
+    fn get_project_types<'a>(&self) -> &'a [&'a str];
+    fn get_supported_loaders<'a>(&self) -> &'a [&'a str];
+    fn get_supported_game_versions(&self) -> SupportedGameVersions;
+    fn validate(
+        &self,
+        archive: &mut ZipArchive<Cursor<&[u8]>>,
+    ) -> Result<ValidationResult, ValidationError>;
+}
+
+static VALIDATORS: [&dyn Validator; 4] = [
+    &PackValidator {},
+    &FabricValidator {},
+    &ForgeValidator {},
+    &LegacyForgeValidator {},
+];
+
+/// The return value is whether this file should be marked as primary or not, based on the analysis of the file
+pub fn validate_file(
+    data: &[u8],
+    file_extension: &str,
+    project_type: &str,
+    loaders: Vec<Loader>,
+    game_versions: Vec<GameVersion>,
+    all_game_versions: &[crate::database::models::categories::GameVersion],
+) -> Result<ValidationResult, ValidationError> {
+    let reader = std::io::Cursor::new(data);
+    let mut zip = zip::ZipArchive::new(reader)?;
+
+    for validator in &VALIDATORS {
+        if validator.get_file_extensions().contains(&file_extension)
+            && validator.get_project_types().contains(&project_type)
+            && loaders
+                .iter()
+                .any(|x| validator.get_supported_loaders().contains(&&*x.0))
+            && game_version_supported(
+                &game_versions,
+                all_game_versions,
+                validator.get_supported_game_versions(),
+            )
+        {
+            return validator.validate(&mut zip);
+        }
+    }
+
+    Ok(ValidationResult::Pass)
+}
+
+fn game_version_supported(
+    game_versions: &[GameVersion],
+    all_game_versions: &[crate::database::models::categories::GameVersion],
+    supported_game_versions: SupportedGameVersions,
+) -> bool {
+    match supported_game_versions {
+        SupportedGameVersions::All => true,
+        SupportedGameVersions::PastDate(date) => game_versions.iter().any(|x| {
+            all_game_versions
+                .iter()
+                .find(|y| y.version == x.0)
+                .map(|x| x.date > date)
+                .unwrap_or(false)
+        }),
+        SupportedGameVersions::Range(before, after) => game_versions.iter().any(|x| {
+            all_game_versions
+                .iter()
+                .find(|y| y.version == x.0)
+                .map(|x| x.date > before && x.date < after)
+                .unwrap_or(false)
+        }),
+        SupportedGameVersions::Custom(versions) => {
+            versions.iter().any(|x| game_versions.contains(x))
+        }
+    }
+}
+
+//todo: fabric/forge validators for 1.8+ respectively

src/validate/pack.rs

@@ -0,0 +1,97 @@
+use crate::models::projects::SideType;
+use crate::validate::{SupportedGameVersions, ValidationError, ValidationResult};
+use serde::{Deserialize, Serialize};
+use std::io::{Cursor, Read};
+use zip::ZipArchive;
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PackFormat {
+    pub game: String,
+    pub format_version: i32,
+    pub version_id: String,
+    pub name: String,
+    pub summary: Option<String>,
+    pub dependencies: std::collections::HashMap<PackDependency, String>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PackFile {
+    pub path: String,
+    pub hashes: std::collections::HashMap<String, String>,
+    pub env: Environment,
+    pub downloads: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Environment {
+    pub client: SideType,
+    pub server: SideType,
+}
+
+#[derive(Serialize, Deserialize, Clone, Hash, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub enum PackDependency {
+    Forge,
+    FabricLoader,
+    Minecraft,
+}
+
+impl std::fmt::Display for PackDependency {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(fmt, "{}", self.as_str())
+    }
+}
+
+impl PackDependency {
+    // These are constant, so this can remove unneccessary allocations (`to_string`)
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            PackDependency::Forge => "forge",
+            PackDependency::FabricLoader => "fabric-loader",
+            PackDependency::Minecraft => "minecraft",
+        }
+    }
+}
+
+pub struct PackValidator {}
+
+impl super::Validator for PackValidator {
+    fn get_file_extensions<'a>(&self) -> &'a [&'a str] {
+        &["zip"]
+    }
+
+    fn get_project_types<'a>(&self) -> &'a [&'a str] {
+        &["modpack"]
+    }
+
+    fn get_supported_loaders<'a>(&self) -> &'a [&'a str] {
+        &["forge", "fabric"]
+    }
+
+    fn get_supported_game_versions(&self) -> SupportedGameVersions {
+        SupportedGameVersions::All
+    }
+
+    fn validate(
+        &self,
+        archive: &mut ZipArchive<Cursor<&[u8]>>,
+    ) -> Result<ValidationResult, ValidationError> {
+        let mut file = archive.by_name("index.json")?;
+
+        let mut contents = String::new();
+        file.read_to_string(&mut contents)?;
+
+        let pack: PackFormat = serde_json::from_str(&*contents)?;
+
+        if pack.game != *"minecraft" {
+            return Err(ValidationError::InvalidInputError(format!(
+                "Game {0} does not exist!",
+                pack.game
+            )));
+        }
+
+        Ok(ValidationResult::Pass)
+    }
+}