Merge pull request #11 from sakihet/develop

Develop

Author: sakihet

.gemini/settings.json

@@ -0,0 +1,9 @@
+{
+    "tools": {
+        "allowed": [
+            "run_shell_command(cargo)",
+            "run_shell_command(git diff)",
+            "run_shell_command(make)"
+        ]
+    }
+}

Cargo.lock

@@ -18,5 +18,6 @@ reqwest = { version = "0.12.24", features = ["json"] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"
 textplots = "0.8.7"
+thiserror = "2.0"
 tokio = { version = "1.48.0", features = ["macros", "rt-multi-thread"] }
 toml = "0.9.11"

Cargo.toml

@@ -32,7 +32,7 @@ Commands:
   config                     Manage configuration
   dream-team                 Show dream team
   fixture                    Show upcoming fixtures
-  fixture-difficulty-rating  Show fixture difficulty rating
+  fixture-difficulty-rating  Show fixture difficulty rating [aliases: fdr]
   gameweek                   Show gameweeks
   history                    Show manager's season history
   live                       Show live player stats for a specific event
@@ -44,6 +44,7 @@ Commands:
   status                     Show status
   table                      Show league table
   team                       Show teams
+  team-form                  Show team form based on total player form
   team-perf                  Show team performance based on player points per GW
   transfer                   Show popular transfers
   help                       Print this message or the help of the given subcommand(s)

README.md

@@ -1,5 +1,6 @@
 use serde::de::DeserializeOwned;
 
+use crate::error::Result;
 use crate::models::{
     BootstrapStatic, DreamTeam, Fixture, LiveData, ManagerHistory, ManagerPicks, PlayerSummary,
     SetPieceNotes,
@@ -10,49 +11,42 @@ const BASE_URL: &str = "https://fantasy.premierleague.com/api";
 pub struct FplClient;
 
 impl FplClient {
-    async fn fetch<T: DeserializeOwned>(endpoint: &str) -> Result<T, Box<dyn std::error::Error>> {
+    async fn fetch<T: DeserializeOwned>(endpoint: &str) -> Result<T> {
         let url = format!("{}{}", BASE_URL, endpoint);
         let response = reqwest::get(&url).await?;
         let json: T = response.json().await?;
         Ok(json)
     }
 
-    pub async fn fetch_bootstrap_static() -> Result<BootstrapStatic, Box<dyn std::error::Error>> {
+    pub async fn fetch_bootstrap_static() -> Result<BootstrapStatic> {
         Self::fetch("/bootstrap-static/").await
     }
 
-    pub async fn fetch_dream_team(event_id: u32) -> Result<DreamTeam, Box<dyn std::error::Error>> {
+    pub async fn fetch_dream_team(event_id: u32) -> Result<DreamTeam> {
         Self::fetch(&format!("/dream-team/{}/", event_id)).await
     }
 
-    pub async fn fetch_fixtures() -> Result<Vec<Fixture>, Box<dyn std::error::Error>> {
+    pub async fn fetch_fixtures() -> Result<Vec<Fixture>> {
         Self::fetch("/fixtures/").await
     }
 
-    pub async fn fetch_live(event_id: u32) -> Result<LiveData, Box<dyn std::error::Error>> {
+    pub async fn fetch_live(event_id: u32) -> Result<LiveData> {
         Self::fetch(&format!("/event/{}/live/", event_id)).await
     }
 
-    pub async fn fetch_manager_picks(
-        manager_id: u64,
-        event_id: u32,
-    ) -> Result<ManagerPicks, Box<dyn std::error::Error>> {
+    pub async fn fetch_manager_picks(manager_id: u64, event_id: u32) -> Result<ManagerPicks> {
         Self::fetch(&format!("/entry/{}/event/{}/picks/", manager_id, event_id)).await
     }
 
-    pub async fn fetch_player_summary(
-        player_id: u64,
-    ) -> Result<PlayerSummary, Box<dyn std::error::Error>> {
+    pub async fn fetch_player_summary(player_id: u64) -> Result<PlayerSummary> {
         Self::fetch(&format!("/element-summary/{}/", player_id)).await
     }
 
-    pub async fn fetch_manager_history(
-        manager_id: u64,
-    ) -> Result<ManagerHistory, Box<dyn std::error::Error>> {
+    pub async fn fetch_manager_history(manager_id: u64) -> Result<ManagerHistory> {
         Self::fetch(&format!("/entry/{}/history/", manager_id)).await
     }
 
-    pub async fn fetch_set_piece_notes() -> Result<SetPieceNotes, Box<dyn std::error::Error>> {
+    pub async fn fetch_set_piece_notes() -> Result<SetPieceNotes> {
         Self::fetch("/team/set-piece-notes/").await
     }
 }

src/api.rs

@@ -1,114 +1,109 @@
 use crate::api::FplClient;
+use crate::error::Result;
 use crate::models::{Element, Position};
 use crate::utils::team_helpers::{create_team_map, find_team_ids_by_name};
 use owo_colors::OwoColorize;
 
-pub async fn handle_availability(team: Option<String>, all: bool, limit: usize) {
-    match FplClient::fetch_bootstrap_static().await {
-        Ok(data) => {
-            let team_map = create_team_map(&data.teams);
-            let target_team_ids = if let Some(ref team_name) = team {
-                find_team_ids_by_name(&data.teams, team_name)
+pub async fn handle_availability(team: Option<String>, all: bool, limit: usize) -> Result<()> {
+    let data = FplClient::fetch_bootstrap_static().await?;
+
+    let team_map = create_team_map(&data.teams);
+    let target_team_ids = if let Some(ref team_name) = team {
+        find_team_ids_by_name(&data.teams, team_name)
+    } else {
+        Vec::new()
+    };
+
+    let mut players: Vec<Element> = data
+        .elements
+        .into_iter()
+        .filter(|player| {
+            let team_match = if team.is_some() {
+                target_team_ids.contains(&player.team)
             } else {
-                Vec::new()
+                true
             };
 
-            let mut players: Vec<Element> = data
-                .elements
-                .into_iter()
-                .filter(|player| {
-                    let team_match = if team.is_some() {
-                        target_team_ids.contains(&player.team)
-                    } else {
-                        true
-                    };
-
-                    if !team_match {
-                        return false;
-                    }
-
-                    // If not "all", only show players with news or non-available status
-                    if !all && player.status == "a" && player.news.is_empty() {
-                        return false;
-                    }
-
-                    true
-                })
-                .collect();
-
-            if players.is_empty() {
-                println!("No availability issues found.");
-                return;
+            if !team_match {
+                return false;
             }
 
-            // Sort players by news_added (latest first)
-            players.sort_by(|a, b| b.news_added.cmp(&a.news_added));
-
-            println!(
-                "{:<4} {:<20} {:<16} {:<4} {:<10} {:<8} {:<18} {:<30}",
-                "ID", "Name", "Team", "Pos", "Status", "Chance", "News Added", "News"
-            );
-
-            for player in players.iter().take(limit) {
-                let team_name = team_map
-                    .get(&player.team)
-                    .map(|s| s.as_str())
-                    .unwrap_or("Unknown");
-
-                let status_desc = match player.status.as_str() {
-                    "a" => "Available",
-                    "i" => "Injured",
-                    "d" => "Doubtful",
-                    "s" => "Suspended",
-                    "n" => "Not Available",
-                    "u" => "Unavail",
-                    _ => &player.status,
-                };
-
-                let chance_val = player.chance_of_playing_next_round;
-                let chance_str = chance_val
-                    .map(|c| format!("{}%", c))
-                    .unwrap_or_else(|| "N/A".to_string());
-
-                let chance_padding = " ".repeat(8usize.saturating_sub(chance_str.len()));
-
-                let colored_chance = match chance_val {
-                    Some(75) => chance_str.yellow().to_string(),
-                    Some(50) => chance_str.truecolor(255, 165, 0).to_string(),
-                    Some(0) => chance_str.red().to_string(),
-                    _ => chance_str,
-                };
-
-                let news_added = player
-                    .news_added
-                    .as_ref()
-                    .map(|s| {
-                        if s.len() >= 16 {
-                            s[..16].replace('T', " ")
-                        } else {
-                            s.clone()
-                        }
-                    })
-                    .unwrap_or_else(|| "N/A".to_string());
-
-                println!(
-                    "{:<4} {:<20} {:<16} {:<4} {:<10} {}{} {:<18} {:<30}",
-                    player.id,
-                    player.web_name,
-                    team_name,
-                    Position::from_element_type_id(player.element_type)
-                        .map(|p| p.display_name().to_string())
-                        .unwrap_or_default(),
-                    status_desc,
-                    chance_padding,
-                    colored_chance,
-                    news_added,
-                    player.news
-                );
+            // If not "all", only show players with news or non-available status
+            if !all
+                && player
+                    .status
+                    .is_available(player.chance_of_playing_next_round)
+                && player.news.is_empty()
+            {
+                return false;
             }
-        }
-        Err(e) => {
-            eprintln!("Error: {}", e);
-        }
+
+            true
+        })
+        .collect();
+
+    if players.is_empty() {
+        println!("No availability issues found.");
+        return Ok(());
     }
+
+    // Sort players by news_added (latest first)
+    players.sort_by(|a, b| b.news_added.cmp(&a.news_added));
+
+    println!(
+        "{:<4} {:<20} {:<16} {:<4} {:<10} {:<8} {:<18} {:<30}",
+        "ID", "Name", "Team", "Pos", "Status", "Chance", "News Added", "News"
+    );
+
+    for player in players.iter().take(limit) {
+        let team_name = team_map
+            .get(&player.team)
+            .map(|s| s.as_str())
+            .unwrap_or("Unknown");
+
+        let status_desc = player.status.display_name();
+
+        let chance_val = player.chance_of_playing_next_round;
+        let chance_str = chance_val
+            .map(|c| format!("{}%", c))
+            .unwrap_or_else(|| "N/A".to_string());
+
+        let chance_padding = " ".repeat(8usize.saturating_sub(chance_str.len()));
+
+        let colored_chance = match chance_val {
+            Some(75) => chance_str.yellow().to_string(),
+            Some(50) => chance_str.truecolor(255, 165, 0).to_string(),
+            Some(0) => chance_str.red().to_string(),
+            _ => chance_str,
+        };
+
+        let news_added = player
+            .news_added
+            .as_ref()
+            .map(|s| {
+                if s.len() >= 16 {
+                    s[..16].replace('T', " ")
+                } else {
+                    s.clone()
+                }
+            })
+            .unwrap_or_else(|| "N/A".to_string());
+
+        println!(
+            "{:<4} {:<20} {:<16} {:<4} {:<10} {}{} {:<18} {:<30}",
+            player.id,
+            player.web_name,
+            team_name,
+            Position::from_element_type_id(player.element_type)
+                .map(|p| p.display_name().to_string())
+                .unwrap_or_default(),
+            status_desc,
+            chance_padding,
+            colored_chance,
+            news_added,
+            player.news
+        );
+    }
+
+    Ok(())
 }

src/commands/availability.rs

@@ -1,4 +1,5 @@
 use crate::config::Config;
+use crate::error::{FplrError, Result};
 use clap::{Args, Subcommand};
 
 #[derive(Debug, Args)]
@@ -25,7 +26,7 @@ pub enum ConfigCommands {
     List,
 }
 
-pub fn handle_config(args: ConfigArgs) {
+pub fn handle_config(args: ConfigArgs) -> Result<()> {
     match args.command {
         ConfigCommands::Set { key, value } => {
             let mut config = Config::load().unwrap_or_default();
@@ -35,16 +36,11 @@ pub fn handle_config(args: ConfigArgs) {
                     let mut user = config.user.unwrap_or_default();
                     user.manager_id = Some(value.clone());
                     config.user = Some(user);
-
-                    if let Err(e) = config.save() {
-                        eprintln!("Failed to save config: {}", e);
-                    } else {
-                        println!("Successfully updated manager-id to {}", value);
-                    }
+                    config.save()?;
+                    println!("Successfully updated manager-id to {}", value);
                 }
                 _ => {
-                    eprintln!("Unknown configuration key: {}", key);
-                    eprintln!("Available keys: manager-id");
+                    return Err(FplrError::UnknownConfigKey(key));
                 }
             }
         }
@@ -63,7 +59,7 @@ pub fn handle_config(args: ConfigArgs) {
                     }
                 }
                 _ => {
-                    eprintln!("Unknown configuration key: {}", key);
+                    return Err(FplrError::UnknownConfigKey(key));
                 }
             }
         }
@@ -84,4 +80,5 @@ pub fn handle_config(args: ConfigArgs) {
             }
         }
     }
+    Ok(())
 }