hvz/

admin.rs

use std::fs;

use chrono::{Datelike, Utc};
use diesel::{ExpressionMethods, QueryDsl, RunQueryDsl, dsl::count_star, sql_query};
use password_auth::generate_hash;

use crate::{
    establish_connection,
    player::{Player, PlayerState},
    schema::players,
    settings::{CHECKPOINT, Settings},
    time::CustomDateTime,
    zombie::Zombie,
};

/// Represents an admin user.
pub type Admin = Player;

impl Admin {
    /// Allows an admin to recover a player's password.
    ///
    /// # Arguments
    /// * `username` - The username of the player to recover the password for.
    /// * `password` - The new password to set for the player.
    ///
    /// # Returns
    /// * `Ok(())` if the password was successfully recovered.
    /// * `Err(String)` if an error occurred.
    pub async fn recover_password(&self, username: String, password: String) -> Result<(), String> {
        let connection = &mut establish_connection();

        diesel::update(players::table.filter(players::alias.eq(username)))
            .set(players::password.eq(generate_hash(password)))
            .execute(connection)
            .expect("Failed to update player");

        Ok(())
    }

    /// Returns the number of players of each possible player state.
    ///
    /// # Returns
    /// * `Ok(String)` if the count was successfully retrieved.
    /// * `Err(String)` if an error occurred.
    pub async fn count_player(&self) -> Result<String, String> {
        let connection = &mut establish_connection();

        let total = players::table
            .count()
            .get_result::<i64>(connection)
            .expect("Error counting the players.");
        let count = players::table
            .group_by(players::state)
            .select((players::state, count_star()))
            .load::<(PlayerState, i64)>(connection)
            .expect("Error loading the roles");

        let mut result = format!("Total players: {}", total.to_string());

        let state_string = count
            .iter()
            .map(|state| {
                format!(
                    "{}: {}, ",
                    match state.0 {
                        PlayerState::Human => "Humans",
                        PlayerState::Zombie => "Zombies",
                        PlayerState::Zombie0 => "Zombie0",
                        PlayerState::Corpse => "Corpse",
                        _ => "Others",
                    },
                    state.1
                )
            })
            .collect::<String>();

        result.push_str(&state_string[..state_string.len() - 2]);

        Ok(result)
    }

    /// Get all players for admins
    ///
    /// # Returns
    /// * `Ok(Vec<Player>)` if the players were successfully retrieved.
    /// * `Err(String)` if an error occurred.
    pub async fn admin_get_players(&self) -> Result<Vec<Player>, String> {
        let connection = &mut establish_connection();

        let players = players::table
            .order(players::player_number.asc())
            .load::<Player>(connection)
            .map_err(|e| format!("Error selecting players: {}", e))?;

        Ok(players)
    }

    /// Feeds a certain amount of players
    ///
    /// # Arguments
    /// * `n` - The amount of players to feed.
    /// * `time` - The time in hours to feed the players.
    ///
    /// # Returns
    /// * `Ok(String)` if the players were successfully fed.
    /// * `Err(String)` if an error occurred.
    pub async fn feed_players(&self, n: i32, time: i32) -> Result<String, String> {
        let connection = &mut establish_connection();

        let mut query = players::table
            .filter(players::state.ne(PlayerState::Human))
            .filter(players::state.ne(PlayerState::Corpse))
            .order(players::next_feeding.asc())
            .into_boxed();
        if n != 0 {
            query = query.limit(n as i64);
        }
        let target_players = query
            .load::<Player>(connection)
            .map_err(|e| format!("Error selecting players to feed: {}", e))?;

        for player in target_players.clone() {
            player.feed(Some(time as i64)).await?;
        }

        Ok(format!("{} players fed", target_players.len()))
    }

    /// Feeds a single player.
    ///
    /// # Arguments
    /// * `username` - The username of the player to feed.
    ///
    /// # Returns
    /// * `Ok(String)` if the player was successfully fed.
    /// * `Err(String)` if an error occurred.
    pub async fn admin_feed(&self, username: String) -> Result<String, String> {
        let connection = &mut establish_connection();

        let result = diesel::update(players::table.filter(players::alias.eq(username)))
            .set(players::next_feeding.eq(Zombie::feeding_time_calc()?))
            .execute(connection)
            .map_err(|e| format!("Error feeding player: {}", e))?;

        Ok(format!("{} player fed", result))
    }

    /// Adds a day to the zombies' feeding time.
    ///
    /// # Returns
    /// * `Ok(String)` if the zombies were successfully fed.
    /// * `Err(String)` if an error occurred.
    pub async fn feed_zombies_day(&self) -> Result<String, String> {
        let connection = &mut establish_connection();

        let mut target_players = players::table
            .filter(players::next_feeding.is_not_null())
            .load::<Player>(connection)
            .map_err(|e| format!("Error loading zombies to feed: {}", e))?;

        for player in &mut target_players {
            if let Some(next_feeding) = player.next_feeding {
                let mut new_next_feeding = next_feeding + chrono::Duration::days(1);
                let weekday = new_next_feeding.weekday().number_from_monday();
                if weekday == 5 || weekday == 6 {
                    new_next_feeding += chrono::Duration::days(2);
                }
                diesel::update(players::table.filter(players::id.eq(&player.id)))
                    .set(players::next_feeding.eq(new_next_feeding))
                    .execute(connection)
                    .map_err(|e| {
                        format!(
                            "Error updating next_feeding for player {}: {}",
                            player.id, e
                        )
                    })?;
            }
        }

        Ok(format!("{} zombies fed", target_players.len()))
    }

    /// Cures a player.
    ///
    /// # Arguments
    /// * `id` - The ID of the player to cure.
    ///
    /// # Returns
    /// * `Ok(String)` if the player was successfully cured.
    /// * `Err(String)` if an error occurred.
    pub async fn cure(&self, id: String) -> Result<String, String> {
        let connection = &mut establish_connection();

        self.transform(id.clone(), PlayerState::Human).await?;

        let result = diesel::update(players::table.filter(players::id.eq(id)))
            .set(players::next_feeding.eq(Option::<CustomDateTime>::None))
            .execute(connection)
            .map_err(|e| format!("Error transforming player: {}", e))?;

        Ok(format!("{} player transformed", result))
    }

    /// Transforms a player into a certain state.
    ///
    /// # Arguments
    /// * `alias` - The alias of the player to transform.
    /// * `state` - The state to transform the player into.
    ///
    /// # Returns
    /// * `Ok(String)` if the player was successfully transformed.
    /// * `Err(String)` if an error occurred.
    pub async fn transform(&self, alias: String, state: PlayerState) -> Result<String, String> {
        let connection = &mut establish_connection();

        let new_feeding_time = match state {
            PlayerState::Zombie | PlayerState::Zombie0 => {
                let new_feeding_time: CustomDateTime = Self::feeding_time_calc()?;
                Some(new_feeding_time)
            }
            _ => None,
        };

        let result = diesel::update(players::table.filter(players::alias.eq(alias)))
            .set((
                players::state.eq(state),
                players::next_feeding.eq(new_feeding_time),
            ))
            .execute(connection)
            .map_err(|e| format!("Error transforming player: {}", e))?;

        Ok(format!("{} player transformed", result))
    }

    /// Sets a player passing through the checkpoint
    ///
    /// # Arguments
    /// * `player_id` (player that is at checkpoint)
    ///
    /// # Returns
    /// * `Ok(String)` if the player was registered at the checkpoint successfully.
    /// * `Err(String)` if an error occurred.
    pub async fn player_at_checkpoint(&self, player_id: String) -> Result<String, String> {
        let connection = &mut establish_connection();

        let mut player = Player::get_player(player_id.clone()).await?;
        if player.is_none() {
            player = Player::get_player_by_alias(player_id).await?;
        }

        match player {
            Some(player) => {
                diesel::update(players::table)
                    .filter(players::id.eq(player.id))
                    .set(players::checkpoint.eq(Utc::now().naive_local()))
                    .execute(connection)
                    .expect("Failed to update player checkpoint");
                Ok(format!("Player {} is at checkpoint", player.name))
            }
            None => Err("Player not found".to_string()),
        }
    }

    /// Kills all players did not go through the checkpoint.
    ///
    /// # Returns
    /// * `Ok(String)` if the players were killed successfully.
    /// * `Err(String)` if an error occurred.
    pub async fn kill_all_not_at_checkpoint(&self) -> Result<String, String> {
        let connection = &mut establish_connection();

        let result = diesel::update(players::table)
            .filter(players::checkpoint.is_null())
            .filter(players::state.eq(PlayerState::Human))
            .filter(players::state.eq(PlayerState::Revived))
            .set(players::state.eq(PlayerState::Corpse))
            .execute(connection)
            .map_err(|e| format!("Failed to kill players: {}", e))?;

        Ok(format!("Killed {} players", result))
    }

    /// Allows an admin to inject SQL commands.
    ///
    /// # Arguments
    /// * `sql_command` - The SQL command to execute.
    ///
    /// # Returns
    /// * `Ok(String)` if the SQL command was successfully executed.
    /// * `Err(String)` if an error occurred.
    pub async fn inject_sql(&self, sql_command: String) -> Result<String, String> {
        let connection = &mut establish_connection();

        let result = sql_query(&sql_command)
            .execute(connection)
            .map_err(|e| format!("SQL execution error: {}", e))?;

        Ok(format!("Changed {} entries", result))
    }

    /// Retrieves the logs from the application.
    ///
    /// # Returns
    /// * `Ok(String)` if the logs were successfully retrieved.
    /// * `Err(String)` if an error occurred.
    pub async fn get_logs(&self) -> Result<String, String> {
        let log_file_path = Some("log/app.log");

        let log_file_path = match log_file_path {
            Some(path) => path,
            None => {
                return Err(
                    "Could not determine log file path from log4rs configuration.".to_string(),
                );
            }
        };

        let log_content = fs::read_to_string(&log_file_path)
            .map_err(|e| format!("Failed to read log file: {}", e))?;

        Ok(log_content)
    }
}