Add mod lists for modpacks, liteloader support, update actix, fix moderation webhook (#357)

src/validate/liteloader.rs

@@ -0,0 +1,38 @@
+use crate::validate::{
+    SupportedGameVersions, ValidationError, ValidationResult,
+};
+use std::io::Cursor;
+use zip::ZipArchive;
+
+pub struct LiteLoaderValidator;
+
+impl super::Validator for LiteLoaderValidator {
+    fn get_file_extensions(&self) -> &[&str] {
+        &["litemod"]
+    }
+
+    fn get_project_types(&self) -> &[&str] {
+        &["mod"]
+    }
+
+    fn get_supported_loaders(&self) -> &[&str] {
+        &["liteloader"]
+    }
+
+    fn get_supported_game_versions(&self) -> SupportedGameVersions {
+        SupportedGameVersions::All
+    }
+
+    fn validate(
+        &self,
+        archive: &mut ZipArchive<Cursor<bytes::Bytes>>,
+    ) -> Result<ValidationResult, ValidationError> {
+        archive.by_name("litemod.json").map_err(|_| {
+            ValidationError::InvalidInput(
+                "No litemod.json present for LiteLoader file.".into(),
+            )
+        })?;
+
+        Ok(ValidationResult::Pass)
+    }
+}

src/validate/mod.rs

@@ -1,6 +1,8 @@
+use crate::models::pack::PackFormat;
 use crate::models::projects::{GameVersion, Loader};
 use crate::validate::fabric::FabricValidator;
 use crate::validate::forge::{ForgeValidator, LegacyForgeValidator};
+use crate::validate::liteloader::LiteLoaderValidator;
 use crate::validate::pack::PackValidator;
 use crate::validate::quilt::QuiltValidator;
 use std::io::Cursor;
@@ -10,6 +12,7 @@ use zip::ZipArchive;
 
 mod fabric;
 mod forge;
+mod liteloader;
 mod pack;
 mod quilt;
 
@@ -29,12 +32,24 @@ pub enum ValidationError {
 
 #[derive(Eq, PartialEq)]
 pub enum ValidationResult {
+    /// File should be marked as primary with pack file data
+    PassWithPackData(PackFormat),
     /// File should be marked as primary
     Pass,
     /// File should not be marked primary, the reason for which is inside the String
     Warning(&'static str),
 }
 
+impl ValidationResult {
+    pub fn is_passed(&self) -> bool {
+        match self {
+            ValidationResult::PassWithPackData(_) => true,
+            ValidationResult::Pass => true,
+            ValidationResult::Warning(_) => false,
+        }
+    }
+}
+
 pub enum SupportedGameVersions {
     All,
     PastDate(OffsetDateTime),
@@ -54,12 +69,13 @@ pub trait Validator: Sync {
     ) -> Result<ValidationResult, ValidationError>;
 }
 
-static VALIDATORS: [&dyn Validator; 5] = [
+static VALIDATORS: [&dyn Validator; 6] = [
     &PackValidator,
     &FabricValidator,
     &ForgeValidator,
     &LegacyForgeValidator,
     &QuiltValidator,
+    &LiteLoaderValidator,
 ];
 
 /// The return value is whether this file should be marked as primary or not, based on the analysis of the file

src/validate/pack.rs

@@ -1,120 +1,13 @@
-use crate::models::projects::SideType;
-use crate::util::env::parse_strings_from_var;
+use crate::models::pack::{PackFileHash, PackFormat};
 use crate::util::validate::validation_errors_to_string;
 use crate::validate::{
     SupportedGameVersions, ValidationError, ValidationResult,
 };
-use serde::{Deserialize, Serialize};
 use std::io::{Cursor, Read};
 use std::path::Component;
 use validator::Validate;
 use zip::ZipArchive;
 
-#[derive(Serialize, Deserialize, Validate)]
-#[serde(rename_all = "camelCase")]
-pub struct PackFormat<'a> {
-    pub game: &'a str,
-    pub format_version: i32,
-    #[validate(length(min = 3, max = 512))]
-    pub version_id: &'a str,
-    #[validate(length(min = 3, max = 512))]
-    pub name: &'a str,
-    #[validate(length(max = 2048))]
-    pub summary: Option<&'a str>,
-    #[validate]
-    pub files: Vec<PackFile<'a>>,
-    pub dependencies: std::collections::HashMap<PackDependency, &'a str>,
-}
-
-#[derive(Serialize, Deserialize, Validate)]
-#[serde(rename_all = "camelCase")]
-pub struct PackFile<'a> {
-    pub path: &'a str,
-    pub hashes: std::collections::HashMap<FileHash, &'a str>,
-    pub env: Option<std::collections::HashMap<EnvType, SideType>>,
-    #[validate(custom(function = "validate_download_url"))]
-    pub downloads: Vec<&'a str>,
-    pub file_size: u32,
-}
-
-fn validate_download_url(
-    values: &[&str],
-) -> Result<(), validator::ValidationError> {
-    for value in values {
-        let url = url::Url::parse(value)
-            .ok()
-            .ok_or_else(|| validator::ValidationError::new("invalid URL"))?;
-
-        if &url.as_str() != value {
-            return Err(validator::ValidationError::new("invalid URL"));
-        }
-
-        let domains = parse_strings_from_var("WHITELISTED_MODPACK_DOMAINS")
-            .unwrap_or_default();
-        if !domains.contains(
-            &url.domain()
-                .ok_or_else(|| validator::ValidationError::new("invalid URL"))?
-                .to_string(),
-        ) {
-            return Err(validator::ValidationError::new(
-                "File download source is not from allowed sources",
-            ));
-        }
-    }
-
-    Ok(())
-}
-
-#[derive(Serialize, Deserialize, Eq, PartialEq, Hash)]
-#[serde(rename_all = "camelCase", from = "String")]
-pub enum FileHash {
-    Sha1,
-    Sha512,
-    Unknown(String),
-}
-
-impl From<String> for FileHash {
-    fn from(s: String) -> Self {
-        return match s.as_str() {
-            "sha1" => FileHash::Sha1,
-            "sha512" => FileHash::Sha512,
-            _ => FileHash::Unknown(s),
-        };
-    }
-}
-
-#[derive(Serialize, Deserialize, Eq, PartialEq, Hash)]
-#[serde(rename_all = "camelCase")]
-pub enum EnvType {
-    Client,
-    Server,
-}
-
-#[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 {
-        fmt.write_str(self.as_str())
-    }
-}
-
-impl PackDependency {
-    // These are constant, so this can remove unnecessary 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 {
@@ -162,20 +55,20 @@ impl super::Validator for PackValidator {
             ));
         }
 
-        for file in pack.files {
-            if file.hashes.get(&FileHash::Sha1).is_none() {
+        for file in &pack.files {
+            if file.hashes.get(&PackFileHash::Sha1).is_none() {
                 return Err(ValidationError::InvalidInput(
                     "All pack files must provide a SHA1 hash!".into(),
                 ));
             }
 
-            if file.hashes.get(&FileHash::Sha512).is_none() {
+            if file.hashes.get(&PackFileHash::Sha512).is_none() {
                 return Err(ValidationError::InvalidInput(
                     "All pack files must provide a SHA512 hash!".into(),
                 ));
             }
 
-            let path = std::path::Path::new(file.path)
+            let path = std::path::Path::new(&file.path)
                 .components()
                 .next()
                 .ok_or_else(|| {
@@ -194,6 +87,6 @@ impl super::Validator for PackValidator {
             };
         }
 
-        Ok(ValidationResult::Pass)
+        Ok(ValidationResult::PassWithPackData(pack))
     }
 }