1 
use serde::{Deserialize, Serialize};
2 
use thiserror::Error;
3 

            

        

            

                4
            

            

                
            

            

                
use crate::core::{

            

        

            

                5
            

            

                
            

            

                
    protocol::request_validation::ValidationError,

            

        

            

                6
            

            

                
            

            

                
    types::{DbOrUser, MySQLUser},

            

        

            

                7
            

            

                
            

            

                
};

            

        

            

                8
            

            

                
            

            

                

            

        

            

                9
            

            

                
            

            

                
pub type SetUserPasswordRequest = (MySQLUser, String);

            

        

            

                10
            

            

                
            

            

                

            

        

            

                11
            

            

                
            

            

                
pub type SetUserPasswordResponse = Result<(), SetPasswordError>;

            

        

            

                12
            

            

                
            

            

                

            

        

            

                13
            

            

                
            

            

                
#[derive(Error, Debug, Clone, PartialEq, Serialize, Deserialize)]

            

        

            

                14
            

            

                
            

            

                
pub enum SetPasswordError {

            

        

            

                15
            

            

                
            

            

                
    #[error("Validation error: {0}")]

            

        

            

                16
            

            

                
            

            

                
    ValidationError(#[from] ValidationError),

            

        

            

                17
            

            

                
            

            

                

            

        

            

                18
            

            

                
            

            

                
    #[error("User does not exist")]

            

        

            

                19
            

            

                
            

            

                
    UserDoesNotExist,

            

        

            

                20
            

            

                
            

            

                

            

        

            

                21
            

            

                
            

            

                
    #[error("MySQL error: {0}")]

            

        

            

                22
            

            

                
            

            

                
    MySqlError(String),

            

        

            

                23
            

            

                
            

            

                
}

            

        

            

                24
            

            

                
            

            

                

            

        

            

                25
            

            

                
            

            

                
pub fn print_set_password_output_status(output: &SetUserPasswordResponse, username: &MySQLUser) {

            

        

            

                26
            

            

                
            

            

                
    match output {

            

        

            

                27
            

            

                
            

            

                
        Ok(()) => {

            

        

            

                28
            

            

                
            

            

                
            println!("Password for user '{username}' set successfully.");

            

        

            

                29
            

            

                
            

            

                
        }

            

        

            

                30
            

            

                
            

            

                
        Err(err) => {

            

        

            

                31
            

            

                
            

            

                
            eprintln!("{}", err.to_error_message(username));

            

        

            

                32
            

            

                
            

            

                
            eprintln!("Skipping...");

            

        

            

                33
            

            

                
            

            

                
        }

            

        

            

                34
            

            

                
            

            

                
    }

            

        

            

                35
            

            

                
            

            

                
}

            

        

            

                36
            

            

                
            

            

                

            

        

            

                37
            

            

                
            

            

                
impl SetPasswordError {

            

        

            

                38
            

            

                
            

            

                
    #[must_use]

            

        

            

                39
            

            

                
            

            

                
    pub fn to_error_message(&self, username: &MySQLUser) -> String {

            

        

            

                40
            

            

                
            

            

                
        match self {

            

        

            

                41
            

            

                
            

            

                
            SetPasswordError::ValidationError(err) => {

            

        

            

                42
            

            

                
            

            

                
                err.to_error_message(&DbOrUser::User(username.clone()))

            

        

            

                43
            

            

                
            

            

                
            }

            

        

            

                44
            

            

                
            

            

                
            SetPasswordError::UserDoesNotExist => {

            

        

            

                45
            

            

                
            

            

                
                format!("User '{username}' does not exist.")

            

        

            

                46
            

            

                
            

            

                
            }

            

        

            

                47
            

            

                
            

            

                
            SetPasswordError::MySqlError(err) => {

            

        

            

                48
            

            

                
            

            

                
                format!("MySQL error: {err}")

            

        

            

                49
            

            

                
            

            

                
            }

            

        

            

                50
            

            

                
            

            

                
        }

            

        

            

                51
            

            

                
            

            

                
    }

            

        

            

                52
            

            

                
            

            

                

            

        

            

                53
            

            

                
            

            

                
    #[allow(dead_code)]

            

        

            

                54
            

            

                
            

            

                
    #[must_use]

            

        

            

                55
            

            

                
            

            

                
    pub fn error_type(&self) -> String {

            

        

            

                56
            

            

                
            

            

                
        match self {

            

        

            

                57
            

            

                
            

            

                
            SetPasswordError::ValidationError(err) => err.error_type(),

            

        

            

                58
            

            

                
            

            

                
            SetPasswordError::UserDoesNotExist => "user-does-not-exist".to_string(),

            

        

            

                59
            

            

                
            

            

                
            SetPasswordError::MySqlError(_) => "mysql-error".to_string(),

            

        

            

                60
            

            

                
            

            

                
        }

            

        

            

                61
            

            

                
            

            

                
    }

            

        

            

                62
            

            

                
            

            

                
}

            

        

            

                63
            

            

                
            

            

                

            

        

            

                64
            

            

                
            

            

                
#[cfg(test)]

            

        

            

                65
            

            

                
            

            

                
mod tests {

            

        

            

                66
            

            

                
            

            

                
    use super::*;

            

        

            

                67
            

            

                
            

            

                

            

        

            

                68
            

            

                
            

            

                
    #[test]

            

        

            

                69
            

            

                1
            

            

                
    fn test_serialize_deserialize_request() {

            

        

            

                70
            

            

                1
            

            

                
        let request: SetUserPasswordRequest = ("test_user".into(), "new_password".into());

            

        

            

                71
            

            

                
            

            

                

            

        

            

                72
            

            

                1
            

            

                
        let json = serde_json::to_string_pretty(&request).unwrap();

            

        

            

                73
            

            

                1
            

            

                
        println!("Serialized request:\n{}", json);

            

        

            

                74
            

            

                
            

            

                

            

        

            

                75
            

            

                1
            

            

                
        let deserialized: SetUserPasswordRequest = serde_json::from_str(&json).unwrap();

            

        

            

                76
            

            

                1
            

            

                
        assert_eq!(request, deserialized);

            

        

            

                77
            

            

                1
            

            

                
    }

            

        

            

                78
            

            

                
            

            

                

            

        

            

                79
            

            

                
            

            

                
    #[test]

            

        

            

                80
            

            

                1
            

            

                
    fn test_serialize_deserialize_response() {

            

        

            

                81
            

            

                1
            

            

                
        let response_ok: SetUserPasswordResponse = Ok(());

            

        

            

                82
            

            

                1
            

            

                
        let response_err: SetUserPasswordResponse = Err(SetPasswordError::UserDoesNotExist);

            

        

            

                83
            

            

                
            

            

                

            

        

            

                84
            

            

                1
            

            

                
        let json_ok = serde_json::to_string_pretty(&response_ok).unwrap();

            

        

            

                85
            

            

                1
            

            

                
        let json_err = serde_json::to_string_pretty(&response_err).unwrap();

            

        

            

                86
            

            

                1
            

            

                
        println!("Serialized OK response:\n{}", json_ok);

            

        

            

                87
            

            

                1
            

            

                
        println!("Serialized Error response:\n{}", json_err);

            

        

            

                88
            

            

                
            

            

                

            

        

            

                89
            

            

                1
            

            

                
        let deserialized_ok: SetUserPasswordResponse = serde_json::from_str(&json_ok).unwrap();

            

        

            

                90
            

            

                1
            

            

                
        let deserialized_err: SetUserPasswordResponse = serde_json::from_str(&json_err).unwrap();

            

        

            

                91
            

            

                1
            

            

                
        assert_eq!(response_ok, deserialized_ok);

            

        

            

                92
            

            

                1
            

            

                
        assert_eq!(response_err, deserialized_err);

            

        

            

                93
            

            

                1
            

            

                
    }

            

        

            

                94
            

            

                
            

            

                
}