markdown shenanigans

src/api/app/actions/markdown/mod.rs

@@ -2,13 +2,46 @@ use std::sync::Arc;
 
 use anyhow::Result;
 
-use crate::api::app::App;
+use crate::api::{app::App, models::{markdown::{MarkdownOptions, MarkdownOutput}, AddonMetadata, AddonMetadataSource}};
 
 impl App {
-    pub async fn render_markdown(self: Arc<Self>) -> Result<()> {
+    pub async fn get_markdown_options(&self) -> Option<MarkdownOptions> {
+        if let Some((_, server)) = &*self.server.read().await {
+            Some(server.markdown.clone())
+        } else {
+            None
+        }
+    }
+
+    pub async fn get_all_metadata(self: Arc<Self>) -> Result<Vec<AddonMetadata>> {
         let addons = self.collect_addons().await?;
 
-
+        let mut metadata = vec![];
+
+        for addon in &addons {
+            // TODO
+            if let Ok(m) = addon.resolve_metadata(&self).await {
+                metadata.push(m);
+            }
+        }
+
+        Ok(metadata)
+    }
+
+    pub async fn render_markdown_with(&self, metadata: Vec<AddonMetadata>) -> Result<String> {
+        let markdown_options = self.get_markdown_options().await.unwrap_or_default();
+
+        let table = markdown_options.render(metadata, markdown_options.output_type);
+
+        Ok(table.render(markdown_options.output_type))
+    }
+
+    pub async fn render_markdown_and_save(self: Arc<Self>) -> Result<()> {
+        let metadata = self.clone().get_all_metadata().await?;
+        let content = self.render_markdown_with(metadata).await?;
+        let options = self.get_markdown_options().await.unwrap_or_default();
+
+        // TODO
 
         Ok(())
     }

src/api/app/mod.rs

@@ -93,5 +93,6 @@ impl App {
         hangar => HangarAPI,
         jenkins => JenkinsAPI,
         quilt => QuiltAPI,
+        spigot => SpigotAPI,
     }
 }

src/api/models/addon/addon.rs

@@ -19,10 +19,10 @@ impl Addon {
             AddonType::Url { url } => resolve_steps_for_url(app, url, None).await,
             AddonType::Modrinth { id, version } => app.modrinth().resolve_steps(id, version).await,
             AddonType::Curseforge { id, version } => Ok(vec![]),
-            AddonType::Spigot { id, version } => todo!(),
-            AddonType::Hangar { id, version } => todo!(),
+            AddonType::Spigot { id, version } => app.spigot().resolve_steps(id, version).await,
+            AddonType::Hangar { id, version } => app.hangar().resolve_steps(id, version).await,
             AddonType::GithubRelease { repo, version, filename } => app.github().resolve_steps(repo, version, filename).await,
-            AddonType::Jenkins { url, job, build, artifact } => todo!(),
+            AddonType::Jenkins { url, job, build, artifact } => app.jenkins().resolve_steps(url, job, build, artifact, None).await,
             AddonType::MavenArtifact { url, group, artifact, version, filename } => app.maven().resolve_steps(url, group, artifact, version, filename).await,
         }
     }

src/api/models/addon/addon_metadata.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
 
 use crate::api::{app::App, sources::{jenkins::jenkins_job_url, maven::maven_artifact_url}, utils::url::get_filename_from_url};
@@ -19,6 +19,27 @@ pub enum AddonMetadataSource {
 }
 
 impl AddonMetadataSource {
+    pub fn all() -> Vec<Self> {
+        vec![
+            AddonMetadataSource::Modrinth,
+            AddonMetadataSource::Hangar,
+            AddonMetadataSource::Spigot,
+            AddonMetadataSource::Other,
+            AddonMetadataSource::Github,
+            AddonMetadataSource::Jenkins,
+            AddonMetadataSource::Maven,
+            AddonMetadataSource::Curseforge,
+        ]
+    }
+
+    pub fn get_markdown_header() -> String {
+        Self::all()
+            .into_iter()
+            .map(|src| format!("[{}]: {}", src.into_str(), src.icon_url()))
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
     pub fn into_str(&self) -> &'static str {
         match self {
             AddonMetadataSource::Modrinth => "modrinth",
@@ -32,8 +53,17 @@ impl AddonMetadataSource {
         }
     }
 
+    pub fn markdown_tag(&self) -> String {
+        format!("![{}]", self.into_str())
+    }
+
+    pub fn html(&self) -> String {
+        format!("<img src='{}'>", self.icon_url())
+    }
+
     pub fn icon_url(&self) -> String {
-        format!("https://raw.githubusercontent.com/ParadigmMC/mcman/main/res/icons/{}.png", self.into_str())
+        // TODO !!!!!!!!!!!!!!!!!!!!!
+        format!("https://raw.githubusercontent.com/ParadigmMC/mcman/v2/res/icons/{}.png", self.into_str())
     }
 }
 
@@ -67,7 +97,7 @@ impl Addon {
                     source: AddonMetadataSource::Modrinth,
                 })
             },
-            AddonType::Curseforge { id, version } => todo!(),
+            AddonType::Curseforge { id, version } => bail!("Unimplemented"),
             AddonType::Spigot { id, version } => todo!(),
             AddonType::Hangar { id, version } => {
                 let proj = app.hangar().fetch_project(id).await?;

src/api/models/markdown/mod.rs

@@ -1,10 +1,24 @@
+use std::collections::HashMap;
+
 use serde::{Deserialize, Serialize};
 
+pub mod render;
+
+#[derive(Debug, Clone, Copy, Default, Deserialize, Serialize, PartialEq)]
+pub enum MarkdownOutput {
+    #[default]
+    ASCII,
+    HTML,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
 pub struct MarkdownOptions {
     pub files: Vec<String>,
     pub columns: Vec<MdColumn>,
+    pub titles: HashMap<MdColumn, String>,
+    pub name_includes_link: bool,
     pub sort_by: MdSort,
+    pub output_type: MarkdownOutput,
 }
 
 impl Default for MarkdownOptions {
@@ -17,18 +31,34 @@ impl Default for MarkdownOptions {
                 MdColumn::Description,
                 MdColumn::Version,
             ],
+            name_includes_link: true,
+            titles: HashMap::new(),
             sort_by: MdSort::default(),
+            output_type: MarkdownOutput::default(),
         }
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
 #[serde(rename_all = "lowercase")]
 pub enum MdColumn {
     Icon,
     Name,
     Description,
     Version,
+    Link,
+}
+
+impl ToString for MdColumn {
+    fn to_string(&self) -> String {
+        match self {
+            MdColumn::Icon => String::from("."),
+            MdColumn::Name => String::from("Name"),
+            MdColumn::Description => String::from("Description"),
+            MdColumn::Version => String::from("Version"),
+            MdColumn::Link => String::from("Link"),
+        }
+    }
 }
 
 

src/api/models/markdown/render.rs

@@ -0,0 +1,46 @@
+use crate::api::{models::AddonMetadata, utils::markdown::{HeaderAlignment, MarkdownHeader, MarkdownTable}};
+
+use super::{MarkdownOptions, MarkdownOutput, MdColumn};
+
+impl MarkdownOptions {
+    pub fn render(&self, list: Vec<AddonMetadata>, output: MarkdownOutput) -> MarkdownTable {
+        let mut table = MarkdownTable::new();
+
+        for column in &self.columns {
+            table.headers.push(MarkdownHeader(self.titles.get(column).cloned().unwrap_or_else(|| column.to_string()), HeaderAlignment::default()));
+        }
+
+        for meta in &list {
+            let mut row = vec![];
+
+            for column in &self.columns {
+                match column {
+                    MdColumn::Name => row.push(if self.name_includes_link {
+                        if let Some(link) = &meta.link {
+                            match output {
+                                MarkdownOutput::ASCII => format!("[{}]({})", meta.name, link),
+                                MarkdownOutput::HTML => format!("<a href={}>{}</a>", link, meta.name),
+                            }
+                        } else {
+                            meta.name.clone()
+                        }
+                    } else {
+                        meta.name.clone()
+                    }),
+                    MdColumn::Description => row.push(meta.description.clone().unwrap_or_default()),
+                    MdColumn::Link => row.push(meta.link.clone().unwrap_or_default()),
+                    MdColumn::Version => row.push(meta.version.clone().unwrap_or_default()),
+                    MdColumn::Icon => row.push(match output {
+                        MarkdownOutput::ASCII => meta.source.markdown_tag(),
+                        MarkdownOutput::HTML => meta.source.html(),
+                        _ => meta.source.into_str().to_owned(),
+                    }),
+                }
+            }
+
+            table.add_row(row);
+        }
+
+        table
+    }
+}

src/api/models/packwiz/mod.rs

@@ -1,13 +1,13 @@
 mod packwiz_mod;
 mod packwiz_pack;
 
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use anyhow::{bail, Result};
 pub use packwiz_mod::*;
 pub use packwiz_pack::*;
 
-use crate::api::{app::App, models::AddonType, utils::accessor::Accessor};
+use crate::api::{app::App, models::AddonType, step::Step, utils::{accessor::Accessor, url::get_filename_from_url}};
 
 pub static PACK_TOML: &str = "pack.toml";
 
@@ -31,7 +31,38 @@ pub async fn resolve_packwiz_addons(app: &App, mut accessor: Accessor) -> Result
     Ok(addons)
 }
 
+impl PackwizModUpdate {
+    pub fn from_addon_type(addon_type: &AddonType) -> Result<Option<Self>> {
+        match addon_type.clone() {
+            AddonType::Modrinth { id, version } => Ok(Some(Self::Modrinth { mod_id: id, version })),
+            AddonType::Curseforge { id, version } => Ok(Some(Self::Curseforge { file_id: version.parse()?, project_id: id.parse()? })),
+            _ => Ok(None),
+        }
+    }
+}
+
+impl PackwizModDownload {
+    pub async fn from_steps(steps: &Vec<Step>) -> Self {
+        todo!()
+    }
+}
+
 impl PackwizMod {
+    // TODO: incomplete
+    pub async fn from_addon(app: &App, addon: &Addon) -> Result<(PathBuf, Self)> {
+        let steps = addon.resolve_steps(app).await?;
+
+        let update = PackwizModUpdate::from_addon_type(&addon.addon_type)?;
+
+        let m = Self {
+            update,
+            side: addon.environment.unwrap_or_default(),
+            ..Default::default()
+        };
+
+        Ok((addon.target.to_path(), m))
+    }
+
     pub async fn into_addon(&self, app: &App, target: AddonTarget) -> Result<Addon> {
         let addon_type = if let Some(update) = &self.update {
             match update {