spigot_rs/

lib.rs

use reqwest::Client;
use serde::Deserialize;

#[derive(Debug, Deserialize, Clone)]
pub struct Premium {
    pub price: String,
    pub currency: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ResourceAuthor {
    pub id: String,
    pub username: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct Reviews {
    pub unique: String,
    pub total: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ResourceStats {
    pub downloads: String,
    pub updates: String,
    pub reviews: Reviews,
    pub rating: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct Resource {
    pub id: String,
    pub title: String,
    pub tag: String,
    pub current_version: String,
    pub native_minecraft_version: Option<String>,
    pub supported_minecraft_versions: Option<Vec<String>>,
    pub premium: Premium,
    pub stats: ResourceStats,
    pub description: String,
    pub icon_link: String,
    pub external_download_url: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ResourceCategory {
    pub id: String,
    pub title: String,
    pub description: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ResourceUpdate {
    pub id: String,
    pub resource_id: String,
    pub title: String,
    pub message: String,
}

#[derive(Debug, Deserialize, Clone)]
pub struct AuthorIdentities {
    pub twitter: Option<String>,
    pub discord: Option<String>,
    pub github: Option<String>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct Author {
    pub id: String,
    pub username: String,
    pub resource_count: String,
    pub identities: AuthorIdentities,
    pub avatar: String,
}

async fn request(url: String) -> anyhow::Result<String> {
    let client = Client::builder()
        .user_agent("Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/114.0")
        .build()?;
    let request = client.get(url).build()?;

    Ok(client
        .execute(request)
        .await?
        .error_for_status()?
        .text()
        .await?)
}

async fn list_resources(url: String) -> anyhow::Result<Vec<Resource>> {
    Ok(serde_json::from_str(&request(url).await?)?)
}

async fn list_resource_updates(url: String) -> anyhow::Result<Vec<ResourceUpdate>> {
    Ok(serde_json::from_str(&request(url).await?)?)
}

pub async fn list_resources_in_category(category: usize) -> anyhow::Result<Vec<Resource>> {
    list_resources(format!(
        "https://api.spigotmc.org/simple/0.2/index.php?action=listResources&category={}",
        category
    ))
    .await
}

pub async fn list_resources_in_category_page(
    category: usize,
    page: usize,
) -> anyhow::Result<Vec<Resource>> {
    list_resources(format!(
        "https://api.spigotmc.org/simple/0.2/index.php?action=listResources&category={}&page={}",
        category, page
    ))
    .await
}

pub async fn list_resources_page(page: usize) -> anyhow::Result<Vec<Resource>> {
    list_resources(format!(
        "https://api.spigotmc.org/simple/0.2/index.php?action=listResources&page={}",
        page
    ))
    .await
}

pub async fn get_resource(id: usize) -> anyhow::Result<Resource> {
    Ok(serde_json::from_str(
        &request(format!(
            "https://api.spigotmc.org/simple/0.2/index.php?action=getResource&id={}",
            id
        ))
        .await?,
    )?)
}

pub async fn get_resources_by_author(id: usize) -> anyhow::Result<Vec<Resource>> {
    list_resources(format!(
        "https://api.spigotmc.org/simple/0.2/index.php?action=getResourcesByAuthor&id={}",
        id
    ))
    .await
}

pub async fn get_resources_by_author_page(id: usize, page: usize) -> anyhow::Result<Vec<Resource>> {
    list_resources(format!(
        "https://api.spigotmc.org/simple/0.2/index.php?action=getResourcesByAuthor&id={}&page={}",
        id, page
    ))
    .await
}

pub async fn list_resource_categories() -> anyhow::Result<Vec<ResourceCategory>> {
    Ok(serde_json::from_str(
        &request(
            "https://api.spigotmc.org/simple/0.2/index.php?action=listResourceCategories"
                .to_string(),
        )
        .await?,
    )?)
}

pub async fn get_resource_update(id: usize) -> anyhow::Result<ResourceUpdate> {
    Ok(serde_json::from_str(
        &request(format!(
            "https://api.spigotmc.org/simple/0.2/index.php?action=getResourceUpdate&id={}",
            id
        ))
        .await?,
    )?)
}

pub async fn get_resource_updates(id: usize) -> anyhow::Result<Vec<ResourceUpdate>> {
    list_resource_updates(format!(
        "https://api.spigotmc.org/simple/0.2/index.php?action=getResourceUpdates&id={}",
        id
    ))
    .await
}

pub async fn get_resource_updates_page(
    id: usize,
    page: usize,
) -> anyhow::Result<Vec<ResourceUpdate>> {
    list_resource_updates(format!(
        "https://api.spigotmc.org/simple/0.2/index.php?action=getResourceUpdates&id={}&page={}",
        id, page
    ))
    .await
}

pub async fn get_author(id: usize) -> anyhow::Result<Author> {
    Ok(serde_json::from_str(
        &request(format!(
            "https://api.spigotmc.org/simple/0.2/index.php?action=getAuthor&id={}",
            id
        ))
        .await?,
    )?)
}

pub async fn find_author(name: &str) -> anyhow::Result<Author> {
    Ok(serde_json::from_str(
        &request(format!(
            "https://api.spigotmc.org/simple/0.2/index.php?action=findAuthor&name={}",
            name
        ))
        .await?,
    )?)
}

#[cfg(test)]
mod tests {
    use crate::{
        find_author, get_author, get_resource, get_resource_update, get_resource_updates,
        get_resources_by_author, get_resources_by_author_page, list_resource_categories,
        list_resources_in_category, list_resources_in_category_page, list_resources_page,
    };

    #[tokio::test]
    async fn test_resources_list() -> anyhow::Result<()> {
        list_resource_categories().await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_resources_list_page() -> anyhow::Result<()> {
        list_resources_page(2).await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_resource_categories() -> anyhow::Result<()> {
        list_resources_in_category(4).await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_resource_categories_page() -> anyhow::Result<()> {
        list_resources_in_category_page(4, 2).await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_get_resource() -> anyhow::Result<()> {
        get_resource(57242).await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_get_resources_by_author() -> anyhow::Result<()> {
        get_resources_by_author(1).await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_get_resources_by_author_page() -> anyhow::Result<()> {
        get_resources_by_author_page(1, 2).await?;

        Ok(())
    }

    #[tokio::test]
    async fn test_list_resource_categories() -> anyhow::Result<()> {
        list_resource_categories().await?;

        Ok(())
    }

    #[tokio::test]
    async fn test_resource_updates() -> anyhow::Result<()> {
        let res = get_resource_updates(57242).await?;
        let update = res.last().unwrap();
        let id = usize::from_str_radix(&update.id.clone(), 10).unwrap();

        get_resource_update(id).await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_get_author() -> anyhow::Result<()> {
        get_author(1).await?;
        Ok(())
    }

    #[tokio::test]
    async fn test_find_author() -> anyhow::Result<()> {
        find_author("md_5").await?;
        Ok(())
    }
}