Fix deserialization with some attributes

The "repository" field doesn't have a type right now, so I'm going to
skip deserializing it. The returned JSON has a value for this field, but
Serde will ignore it.

The `Packages.pkg_type` field is called "type" in the JSON string (and
Go code, as mentioned in the comment). Similarly, the PackageType enum
I have to represent this field in Rust has capital starting letters
where the JSON uses all lowercase. Both problems are solved with a Serde
rename attribute.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gt-tool"
-version = "3.0.0"
+version = "4.0.0-dev"
 edition = "2024"
 
 [dependencies]

src/api/packages.rs

@@ -1,4 +1,40 @@
-pub fn list_packages() {}
+use crate::structs::package::{Package, PackageType};
+
+/// Gets all packages of an owner
+///
+/// https://github.com/go-gitea/gitea/blob/main/routers/api/v1/packages/package.go#L22
+///
+/// Matches the route `GET /packages/{owner}`
+pub async fn list_packages(
+    client: &reqwest::Client,
+    gitea_url: &str,
+    owner: &str,
+    pkg_type: Option<PackageType>,
+) -> crate::Result<Vec<Package>> {
+    let request_url = format!("{gitea_url}/api/v1/packages/{owner}");
+    // add the query parameter only when a package type filter has been set.
+    let request_url = if let Some(pkg_type) = pkg_type {
+        let pkg_type = pkg_type.to_string();
+        format!("{request_url}?type={pkg_type}")
+    } else {
+        request_url
+    };
+    let req = client.get(request_url).send().await;
+    let response = req.map_err(crate::Error::WrappedReqwestErr)?;
+
+    if response.status().is_success() {
+        let release_list = response
+            .json::<Vec<Package>>()
+            .await
+            .map_err(crate::Error::WrappedReqwestErr)?;
+        return Ok(release_list);
+    } else if response.status().is_client_error() {
+        let mesg = crate::decode_client_error(response).await?;
+        return Err(crate::Error::ApiErrorMessage(mesg));
+    }
+    panic!("Reached the end of `api::list_packages()` without matching a return pathway.");
+}
+
 pub fn get_packages() {}
 pub fn delete_package() {}
 pub fn list_package_files() {}

src/cli.rs

@@ -44,4 +44,5 @@ pub enum Commands {
         #[arg()]
         files: Vec<String>,
     },
+    ListPackages,
 }

src/main.rs

@@ -134,6 +134,16 @@ async fn main() -> Result<(), gt_tool::Error> {
                 return Err(gt_tool::Error::NoSuchRelease);
             }
         }
+        gt_tool::cli::Commands::ListPackages => {
+            let packages = gt_tool::api::packages::list_packages(&client, &gitea_url, &owner, None).await?;
+            itertools::Itertools::intersperse(
+                packages
+                    .iter()
+                    .rev()
+                    .map(|pkg| pkg.colorized()),
+                String::from("")
+            ).for_each(|package| println!("{package}"));
+        }
     }
 
     Ok(())

src/structs/mod.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 
+pub mod package;
 pub mod release;
 pub mod repo;
 

src/structs/package.rs

@@ -0,0 +1,95 @@
+use colored::Colorize;
+use serde::{Deserialize, Serialize};
+
+use crate::structs::release::Author;
+
+/// Represents the package as described by JSON
+///
+/// https://github.com/go-gitea/gitea/blob/main/modules/structs/package.go
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Package {
+    created_at: String,          // TODO: Datetime struct
+    creator: Author,
+    html_url: String,
+    id: u64,
+    name: String,
+    owner: Author,
+    #[serde(skip)]
+    repository: (),             // TODO: Create a `struct Repository`
+    #[serde(rename = "type")]   // field is "type" in JSON & Go, but that's a
+    pkg_type: PackageType,      // keyword in Rust so we need to serde-rename it.
+    version: String,
+}
+
+impl Package {
+    pub fn colorized(&self) -> String {
+        let name = "Name:".green().bold();
+        let version = "Ver:".green();
+        let pkg_type = "Type:".white();
+
+        format!(
+            "{name} {}
+{version} {}, {pkg_type} {}",
+            self.name,
+            self.version,
+            self.pkg_type.to_string(),
+        )
+    }
+}
+
+/// A marker for the kind of package being handled.
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum PackageType {
+    Alpine,
+    Arch,
+    Cargo,
+    Chef,
+    Composer,
+    Conan,
+    Conda,
+    Container,
+    Cran,
+    Debian,
+    Generic,
+    Go,
+    Helm,
+    Maven,
+    Npm,
+    Nuget,
+    Pub,
+    PyPi,
+    Rpm,
+    RubyGems,
+    Swift,
+    Vagrant,
+}
+
+impl ToString for PackageType {
+    fn to_string(&self) -> String {
+        match self {
+            PackageType::Alpine => "alpine".into(),
+            PackageType::Arch => "arch".into(),
+            PackageType::Cargo => "cargo".into(),
+            PackageType::Chef => "chef".into(),
+            PackageType::Composer => "composer".into(),
+            PackageType::Conan => "conan".into(),
+            PackageType::Conda => "conda".into(),
+            PackageType::Container => "container".into(),
+            PackageType::Cran => "cran".into(),
+            PackageType::Debian => "debian".into(),
+            PackageType::Generic => "generic".into(),
+            PackageType::Go => "go".into(),
+            PackageType::Helm => "helm".into(),
+            PackageType::Maven => "maven".into(),
+            PackageType::Npm => "npm".into(),
+            PackageType::Nuget => "nuget".into(),
+            PackageType::Pub => "pub".into(),
+            PackageType::PyPi => "pypi".into(),
+            PackageType::Rpm => "rpm".into(),
+            PackageType::RubyGems => "rubygems".into(),
+            PackageType::Swift => "swift".into(),
+            PackageType::Vagrant => "vagrant".into(),
+        }
+    }
+}