convertor 2.6.12

A profile converter for surge/clash.
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
129
130
131
132
133
134
135
136
137
138
139

pub mod boslife_config;

use clap::ValueEnum;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::hash::Hash;
use std::ops::{Deref, DerefMut};
use strum::{AsRefStr, Display, EnumString, IntoStaticStr, VariantArray};
use url::Url;

#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Hash)]
#[derive(ValueEnum, Serialize, Deserialize)]
#[derive(Display, IntoStaticStr, AsRefStr, VariantArray, EnumString)]
#[serde(rename_all = "lowercase")]
pub enum Provider {
    #[default]
    BosLife,
}

#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct ProviderConfig {
    pub provider: Provider,
    pub sub_url: Url,
    pub api_config: ApiConfig,
}

#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct ApiConfig {
    pub host: Url,
    pub prefix: String,
    pub headers: Headers,
    pub credential: Credential,
    pub login_api: Api,
    pub get_sub_api: Api,
    pub reset_sub_api: Api,
    pub sub_logs_api: Option<Api>,
}

#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct Api {
    pub path: String,
    pub json_path: String,
}

#[derive(Default, Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
pub struct Credential {
    pub username: String,
    pub password: String,
}

#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Headers(pub HashMap<String, String>);

impl ApiConfig {
    pub fn login_url(&self) -> Url {
        let mut url = self.host.clone();
        url.set_path(&self.login_path());
        url
    }

    pub fn login_path(&self) -> String {
        format!("{}{}", self.prefix.trim(), self.login_api.path.trim())
            .trim()
            .to_string()
    }

    pub fn get_sub_url(&self) -> Url {
        let mut url = self.host.clone();
        url.set_path(&self.get_sub_path());
        url
    }

    pub fn get_sub_path(&self) -> String {
        format!("{}{}", self.prefix.trim(), self.get_sub_api.path.trim())
            .trim()
            .to_string()
    }

    pub fn reset_sub_url(&self) -> Url {
        let mut url = self.host.clone();
        url.set_path(&self.reset_sub_path());
        url
    }

    pub fn reset_sub_path(&self) -> String {
        format!("{}{}", self.prefix.trim(), self.reset_sub_api.path.trim())
            .trim()
            .to_string()
    }

    pub fn sub_logs_url(&self) -> Option<Url> {
        self.sub_logs_path().map(|path| {
            let mut url = self.host.clone();
            url.set_path(&path);
            url
        })
    }

    pub fn sub_logs_path(&self) -> Option<String> {
        self.sub_logs_api
            .as_ref()
            .map(|api| format!("{}{}", self.prefix.trim(), api.path.trim()).trim().to_string())
    }
}

impl Hash for Headers {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        for (key, value) in &self.0 {
            key.hash(state);
            value.hash(state);
        }
    }
}

impl AsRef<HashMap<String, String>> for Headers {
    fn as_ref(&self) -> &HashMap<String, String> {
        &self.0
    }
}

impl Deref for Headers {
    type Target = HashMap<String, String>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl AsMut<HashMap<String, String>> for Headers {
    fn as_mut(&mut self) -> &mut HashMap<String, String> {
        &mut self.0
    }
}

impl DerefMut for Headers {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}