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
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

mod call;
mod data;

use data::{
    DelogCall,
    DelogLevel,
};



pub async fn delog(
    data: DelogCall,
) -> Result<(), reqwest::Error> {
    use std::env;
    use DelogCall::*;

    // let level = env::var("DELOG_DEFAULT_LEVEL").unwrap_or("3".to_string()).parse().unwrap_or(DelogLevel::Info);
    let level = DelogLevel::Info;

    let endpoint: String = env::var("DELOG_ENDPOINT").unwrap_or("".to_string());
    let token: String = env::var("DELOG_TOKEN").unwrap_or("".to_string());

    let project: String = env::var("DELOG_PROJECT").unwrap_or("".to_string());
    let space: String = env::var("DELOG_SPACE").unwrap_or("".to_string());
    let format: String = env::var("DELOG_FORMAT").unwrap_or("".to_string());
  
    let method: String = env::var("DELOG_METHOD").unwrap_or("".to_string());
    let extradata: String = env::var("DELOG_EXTRADATA").unwrap_or("".to_string());

    match data {
        Str(data) => {
            call::delog_call(
                String::from(data),
                level,
                endpoint,
                token,
                project,
                space,
                format,
                method,
                extradata,
            ).await?;
        }
        Data(data) => {
            let data_level: DelogLevel = data.level.unwrap_or(level);

            let data_endpoint = String::from(data.endpoint.unwrap_or(&endpoint));
            let data_token = String::from(data.token.unwrap_or(&token));

            let data_project = String::from(data.project.unwrap_or(&project));
            let data_space = String::from(data.space.unwrap_or(&space));
            let data_format = String::from(data.format.unwrap_or(&format));
          
            let data_method = String::from(data.method.unwrap_or(&method));
            let data_extradata = String::from(data.extradata.unwrap_or(&extradata));

            call::delog_call(
                String::from(data.text),
                data_level,
                data_endpoint,
                data_token,
                data_project,
                data_space,
                data_format,
                data_method,
                data_extradata,
            ).await?;
        }
    }

    Ok(())
}



#[cfg(test)]
mod tests {
    use super::{
        delog,
        DelogCall,
        DelogLevel,
        data,
    };
    use data::{
        DelogData,
    };

    // #[tokio::test]
    // async fn it_works_string() {
    //     let _sent = delog(DelogCall::Str("it works with string")).await;
    //     // assert_eq!(sent, true);
    // }

    // #[tokio::test]
    // async fn it_works_data() {
    //     let delog_data = DelogData {
    //         text: "it works with data",
    //         ..Default::default()
    //     };
    //     let _sent = delog(DelogCall::Data(delog_data)).await;
    //     // assert_eq!(sent, true);
    // }

    #[tokio::test]
    async fn it_works_with_test_token() {
        let delog_data = DelogData {
            text: "it works with test token",
            level: Some(DelogLevel::Trace),
            endpoint: Some("http://localhost:56365/delog"),
            token: Some("__TEST_MODE__"),
            ..Default::default()
        };
        let _sent = delog(DelogCall::Data(delog_data)).await;
        // assert_eq!(sent, true);
    }
}