doyle 0.0.1

Tool for searching social-media accounts
Documentation 
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
117
118
119
120
121
122
123
124
125
126
127
128

//! # doyle-inner
//! 
//! Contains a description of data model and core traits

#![allow(missing_docs)]
use serde::de::{Error as SerdeError, Visitor};
use serde::{Deserialize, Deserializer};



struct ErrorMsgVisitor;

impl<'de> Visitor<'de> for ErrorMsgVisitor {
    type Value = ErrorMsg;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("vec or string")
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: SerdeError,
    {
        Ok(ErrorMsg {
            msgs: vec![v.to_string()],
        })
    }

    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    where
        A: serde::de::SeqAccess<'de>,
    {
        let mut sequence: Vec<String> = vec![];
        while let Some(value) = seq.next_element()? {
            sequence.push(value);
        }

        Ok(ErrorMsg { msgs: sequence })
    }
}

// Data model often contains situations where ErrorMsg is either Array of strings or
// a string. Serde by default cannot deserialize this, so I implemented Deserialize for
// ErrorMsg
impl<'de> Deserialize<'de> for ErrorMsg {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_any(ErrorMsgVisitor)
    }
}

/// Represents result of check
#[derive(Debug, PartialEq, Eq)]
pub enum Status {
    Found,
    NotFound,
}

/// Used if ErrorType is message to check presence of string in body
#[derive(Debug)]
pub struct ErrorMsg {
    pub msgs: Vec<String>,
}

/// Type of error that host should return
#[derive(Debug, Deserialize)]
pub enum ErrorType {
    /// HTTP Statuc code
    #[serde(alias = "status_code")]
    StatusCode,
    /// A string in the response body
    #[serde(alias = "message")]
    Msg,
    /// Specific url
    #[serde(alias = "response_url")]
    ResponseUrl,
}

/// Details about host
#[derive(Deserialize, Debug)]
pub struct HostDetails {
    #[serde(alias = "errorMsg")]
    pub error_msg: Option<ErrorMsg>,
    /// Optional. Used if host has a separate and known API. 
    #[serde(alias = "urlProbe")]
    pub url_probe: Option<String>,

    #[serde(alias = "errorType")]
    pub error_type: ErrorType,

    pub url: String,
}

#[derive(Deserialize, Debug)]
pub struct Host {
    pub details: HostDetails,
}

/// Result of check
#[derive(Debug, PartialEq, Eq)]
pub struct CheckResult {
    pub url: String,
    pub status: Status,
    /// Time elapsed since start of check
    pub execution_time: u128,
}

#[derive(Default)]
pub struct DoyleData {
    pub username: String,
    pub hosts: Vec<(String, HostDetails)>,
}

pub trait Doyle {
    fn check_host(&self, host: &HostDetails) -> CheckResult;

    fn check_hosts(&self, hosts: &[(String, HostDetails)]) -> Vec<CheckResult>;

    fn builder() -> DoyleBuilder;
}

#[derive(Default)]
pub struct DoyleBuilder {
    pub username: String,
    pub hosts: Vec<(String, HostDetails)>,
}