    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67

    use std::collections::HashMap;
    use serde_json::json;

    use crate::defs::Config;
    use pasetoken_lib::ConfigPaSeToken;

    use crate::defs::{
        CLAIM_UID,
        CLAIM_AUTH,
        CLAIM_APP_KEY,
    };

    #[derive(Debug, Default)]
    pub struct UserNotifyData {
        pub key: String,
        pub id: String,
        pub auth: String,
    }

    impl UserNotifyData {
        pub fn data_claim(&self,_config: &Config) -> HashMap<String,String> {
            HashMap::from([
                (String::from(CLAIM_UID), self.id.to_owned()),
                (String::from(CLAIM_AUTH), self.auth.to_owned()),
                (String::from(CLAIM_APP_KEY), self.key.to_owned()),
            ])
        }
        pub fn token(&self, server_config: &Config, paseto_config: &ConfigPaSeToken, expire: bool) -> String {
            paseto_config.generate_token("", &self.data_claim(server_config), expire).unwrap_or_else(|e|{
                eprintln!("Error generating token: {}", e);
                String::from("")
            })
        }
        pub fn from_token(token: &str,paseto_config: &ConfigPaSeToken) -> (String,Self) {
            match paseto_config.pasetoken() {
                Ok(paseto) => {
                    match paseto.trusted(token, false) {
                        Ok(trusted_token) => {
                            // dbg!(&trusted_token.payload_claims());
                            if let Some(claims) = trusted_token.payload_claims() {
                                // dbg!(&claims);
                                let uid = claims.get_claim(CLAIM_UID).unwrap_or(&json!("")).to_string().replace("\"","");
                                (
                                    uid.to_owned(),
                                    Self {
                                        key: claims.get_claim(CLAIM_APP_KEY).unwrap_or(&json!("")).to_string().replace("\"",""),
                                        id: uid,
                                        auth: claims.get_claim(CLAIM_AUTH).unwrap_or(&json!("")).to_string().replace("\"",""),
                                    }
                                )
                            } else {
                                (String::from(""), Self::default())
                            }
                        },
                        Err(e) => {
                            println!("Token not trusted: {}",e);
                            (String::from(""), Self::default())
                        },
                    }
                },
                Err(e) => {
                    println!("Error collecting notify data: {}",e);
                    (String::from(""), Self::default())
                }
            }
        }
    }