cal_core/

account.rs

use crate::core::*;
use crate::device::{Connector, Device};
use crate::utils::*;
use phonenumber::country;
use phonenumber::country::Id;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;



#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct RecordReference {
    id: String,
    name: String,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct AccountLite {
    pub id: String,
    pub name: String,
    pub mbn: String,
    pub domain: String,
    pub created: Option<String>,
    pub organisation: RecordReference,
    #[serde(default)]
    pub ddis: Vec<DDI>,
    #[serde(default)]
    pub trunks: Vec<Trunk>,
    #[serde(rename = "callbackURLS")]
    pub hooks: Vec<Hook>,
    #[serde(default)]
    pub devices: Vec<Device>,
    #[serde(default)]
    pub environment: Environment,
}

impl AccountLite {
    pub fn country_code(&self) -> &str {
        self.environment.country_code.as_str()
    }

    pub fn country_code_parsed(&self) -> Id {
        self.environment.country_code_parsed()
    }

    pub fn inbound_flow(&self, str: &str) -> Option<Device> {
        match self.ddi(str) {
            Some(ddi) => self.device(&ddi.id),
            None => None,
        }
    }

    pub fn outbound_flow(&self) -> Option<Device> {
        self.devices
            .iter()
            .find(|d| d.match_outbound_flow())
            .map(|d| d.clone())
    }

    pub fn device(&self, id: &str) -> Option<Device> {
        self.devices
            .iter()
            .find(|d| d.match_device(id))
            .map(|d| d.clone())
    }

    pub fn ddi(&self, str: &str) -> Option<DDI> {
        let id = self.clean_str(str);
        self.ddis
            .iter()
            .find(|ddi| ddi.id == id || ddi.name == id)
            .map(|ddi| ddi.clone())
    }

    pub fn traverse(&self, state: &mut FlowState) -> Vec<FlowState> {
        let mut states: Vec<FlowState> = Vec::new();
        while state.device.is_some() {
            match &state.device {
                Some(d) => {
                    let nd = d.clone().get_connect_to(state);
                    states.push(nd);
                }
                None => {
                    //do nothing
                }
            }
        }
        states
    }

    pub fn clean_str(&self, str: &str) -> String {
        clean_str(self.environment.country_code_parsed(), str)
    }
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Account {
    pub id: String,
    pub name: String,
    pub mbn: String,
    pub domain: String,
    // todo #[serde(with = "time::serde::rfc3339::option")]
    pub created: Option<String>,
    pub organisation: RecordReference,
    #[serde(default)]
    pub ddis: Vec<DDI>,
    #[serde(default)]
    pub trunks: Vec<Trunk>,
    #[serde(default)]
    #[serde(rename = "callbackURLS")]
    pub hooks: Vec<Hook>,
    #[serde(default)]
    pub devices: Vec<Device>,
    #[serde(default)]
    pub settings: Vec<Setting>,
    #[serde(default)]
    pub assets: Vec<Asset>,
    #[serde(default)]
    pub address: Address,
    #[serde(default)]
    pub teams: TeamsAccount,
    #[serde(default)]
    pub environment: Environment,
    #[serde(default)]
    pub spend_cap: SpendCap,
    pub concurrency: Concurrency,
    #[serde(default)]
    pub class_of_service: ClassOfService,
    #[serde(default)]
    pub api_keys: APIKeys,
    pub cluster_settings: Cluster,
    pub domain_settings: Domain,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Cluster {
    id: String,
    name: String,
    router: RecordReference,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Domain {
    #[serde(rename = "serverA")]
    server_a: String,
    #[serde(rename = "serverB")]
    server_b: String,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct APIKeys {
    #[serde(default)]
    keys: Vec<APIKey>,
}

impl Default for APIKeys {
    fn default() -> Self {
        Self { keys: Vec::new() }
    }
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct APIKey {
    key: String,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Environment {
    #[serde(default = "build_logger")]
    pub logger: LoggerLevel,
    #[serde(rename = "dialTimeLimit")]
    #[serde(default = "build_call_time")]
    pub max_call_time: u16,
    #[serde(rename = "dialTimeout")]
    #[serde(default = "build_ring_time")]
    pub ring_time: u8,
    #[serde(default = "build_tts_vendor")]
    pub tts_vendor: String,
    #[serde(default = "build_tts_language")]
    #[serde(rename = "ttsLanguageV2")]
    pub tts_language: String,
    #[serde(default = "build_tts_voice")]
    pub tts_voice: String,
    #[serde(default = "build_asr_vendor")]
    pub asr_vendor: String,
    #[serde(default = "build_asr_language")]
    pub asr_language: String,
    #[serde(default = "build_default_timezone")]
    pub time_zone: String,
    #[serde(default = "build_country_code")]
    pub country_code: String,
    #[serde(default = "build_record_retention")]
    pub recording_retention: String,
    pub ingress_script: Option<String>,
}

impl Environment {
    pub fn country_code_parsed(&self) -> Id {
        self.country_code.parse().unwrap_or_else(|_| country::GB)
    }
}
impl Default for Environment {
    fn default() -> Self {
        Self {
            logger: LoggerLevel::Warn,
            max_call_time: DEFAULT_CALL_TIME,
            ring_time: DEFAULT_RING_TIME,
            tts_vendor: DEFAULT_TTS_VENDOR.to_string(),
            tts_language: DEFAULT_TTS_LANGUAGE.to_string(),
            tts_voice: DEFAULT_TTS_VOICE.to_string(),
            asr_vendor: DEFAULT_ASR_VENDOR.to_string(),
            asr_language: DEFAULT_ASR_LANGUAGE.to_string(),
            time_zone: DEFAULT_TIMEZONE.to_string(),
            country_code: DEFAULT_COUNTRY_CODE.to_string(),
            recording_retention: DEFAULT_RECORDING_RETENTION.to_string(),
            ingress_script: None,
        }
    }
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct SpendCap {
    #[serde(default = "build_spend_cap_value")]
    value: u16,
    #[serde(default = "build_spend_cap_level")]
    warn: u8,
    #[serde(default = "build_spend_cap_action")]
    action: RouteAction,
    #[serde(default)]
    email_recipients: Vec<String>,
}

impl Default for SpendCap {
    fn default() -> Self {
        Self {
            value: 100,
            warn: 80,
            action: RouteAction::Warn,
            email_recipients: Vec::new(),
        }
    }
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Concurrency {
    #[serde(rename = "type")]
    #[serde(default = "build_license")]
    license: Licence,
    #[serde(default = "build_concurrency_action")]
    action: RouteAction,
    #[serde(default)]
    email_recipients: Vec<String>,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ClassOfService {
    #[serde(rename = "type")]
    #[serde(default = "build_cos_action")]
    license: COSAction,
    #[serde(default)]
    countries: Vec<String>,
    #[serde(default)]
    prefix_exceptions: String,
    #[serde(rename = "maxPPM")]
    #[serde(default = "build_cos_ppm")]
    max_ppm: f32,
    #[serde(rename = "maxPPC")]
    #[serde(default = "build_cos_ppc")]
    max_ppc: f32,
}

impl Default for ClassOfService {
    fn default() -> Self {
        Self {
            license: COSAction::Allow,
            countries: Vec::new(),
            prefix_exceptions: String::from(""),
            max_ppc: 10.00,
            max_ppm: 10.00,
        }
    }
}

#[derive(Serialize, Deserialize, Clone)]
pub enum LoggerLevel {
    #[serde(rename = "info")]
    Info,
    #[serde(rename = "warn")]
    Warn,
    #[serde(rename = "error")]
    Error,
}

#[derive(Serialize, Deserialize, Clone)]
pub enum Licence {
    #[serde(rename = "standard")]
    Standard,
    #[serde(rename = "professional")]
    Professional,
    #[serde(rename = "enterprise")]
    Enterprise,
}

#[derive(Serialize, Deserialize, Clone)]
pub enum COSAction {
    #[serde(rename = "DENY")]
    Deny,
    #[serde(rename = "ALLOW")]
    Allow,
}

#[derive(Serialize, Deserialize, Clone)]
pub enum RouteAction {
    #[serde(rename = "warn")]
    Warn,
    #[serde(rename = "restrict")]
    Restrict,
    #[serde(rename = "deny")]
    Deny,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct TeamsAccount {
    #[serde(rename = "type")]
    pub domain_type: String,
    #[serde(default)]
    pub domain: String,
    pub txt: Option<String>,
    #[serde(rename = "serverA")]
    pub server_a: String,
    #[serde(rename = "serverB")]
    pub server_b: String,
}

impl Default for TeamsAccount {
    fn default() -> Self {
        Self {
            domain_type: String::from("callable"),
            domain: String::from(""),
            server_a: String::from(""),
            server_b: String::from(""),
            txt: None,
        }
    }
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Address {
    #[serde(default)]
    pub line1: String,
    #[serde(default)]
    pub line2: String,
    #[serde(default)]
    pub level1: String,
    #[serde(default)]
    pub level2: String,
    #[serde(default)]
    pub postal_code: String,
    #[serde(default)]
    pub country: String,
}

impl Default for Address {
    fn default() -> Self {
        Self {
            line1: String::from(""),
            line2: String::from(""),
            level1: String::from(""),
            level2: String::from(""),
            postal_code: String::from(""),
            country: String::from(""),
        }
    }
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Asset {
    id: String,
    bucket: String,
    key: String,
    filename: String,
    name: String,
    mime_type: String,
    size: u32,
    created: String,
    #[serde(default)]
    meta: HashMap<String, String>,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Setting {
    #[serde(default)]
    pub id: String,
    pub key: String,
    #[serde(rename = "type")]
    pub setting_type: String,
    pub value: String,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct DDI {
    pub id: String,
    pub name: String,
    #[serde(default)]
    pub meta: HashMap<String, String>,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Trunk {
    pub id: String,
    pub ip: String,
    #[serde(default = "build_trunk_description")]
    pub description: String,
    #[serde(default = "build_trunk_port")]
    pub port: u16,
}

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Hook {
    pub id: String,
    pub app: String,
    pub url: String,
    #[serde(default = "AuthType::default_method")]
    pub auth_type: AuthType,
    #[serde(default = "HookMethod::default_method")]
    pub method: HookMethod,
    #[serde(default)]
    pub meta: HashMap<String, String>,
    #[serde(default)]
    pub api_key_name: String,
    #[serde(default)]
    pub api_key_value: String,
    #[serde(default)]
    pub api_secret_name: String,
    #[serde(default)]
    pub api_secret_value: String,
}

#[derive(Serialize, Deserialize, Clone)]
pub enum HookMethod {
    #[serde(rename = "POST")]
    Post,
    #[serde(rename = "GET")]
    Get,
}

#[derive(Serialize, Deserialize, Clone)]
pub enum QueueItemType {
    #[serde(rename = "play")]
    Play,
    #[serde(rename = "say")]
    Say,
    #[serde(rename = "pause")]
    Pause,
}

impl HookMethod {
    fn default_method() -> Self {
        HookMethod::Post
    }
}

#[derive(Serialize, Deserialize, Clone)]
pub enum AuthType {
    #[serde(rename = "DISABLED")]
    Disabled,
    #[serde(rename = "KEY")]
    Key,
    #[serde(rename = "KEY_SECRET")]
    KeySecret,
    #[serde(rename = "BASIC_AUTH")]
    BasicAuth,
}

impl AuthType {
    fn default_method() -> Self {
        AuthType::Disabled
    }
}

impl Connector for Device {
    fn get_connect_to(&mut self, state: &mut FlowState) -> FlowState {
        match self {
            Device::InboundFlow(value) => value.get_connect_to(state),
            Device::OutboundFlow(value) => value.get_connect_to(state),
            Device::AppFlow(value) => value.get_connect_to(state),
            Device::WhatsAppFlow(value) => value.get_connect_to(state),
            Device::AniRouter(value) => value.get_connect_to(state),
            Device::DnisRouter(value) => value.get_connect_to(state),
            Device::DigitRouter(value) => value.get_connect_to(state),
            Device::TimeRangeRouter(value) => value.get_connect_to(state),
            Device::DayOfWeekRouter(value) => value.get_connect_to(state),
            Device::DateRangeRouter(value) => value.get_connect_to(state),
            Device::Play(value) => value.get_connect_to(state),
            Device::Say(value) => value.get_connect_to(state),
            Device::Voicemail(value) => value.get_connect_to(state),
            Device::Script(value) => value.get_connect_to(state),
            Device::Queue(value) => value.get_connect_to(state),
            Device::Sms(value) => value.get_connect_to(state),
            Device::Email(value) => value.get_connect_to(state),
            Device::Tag(value) => value.get_connect_to(state),
            Device::TagRouter(value) => value.get_connect_to(state),
            Device::Service(value) => value.get_connect_to(state),
            _ => state.clone(),
        }
    }
}

fn build_asr_vendor() -> String {
    String::from(DEFAULT_ASR_VENDOR)
}

fn build_asr_language() -> String {
    String::from(DEFAULT_ASR_LANGUAGE)
}

fn build_tts_vendor() -> String {
    String::from(DEFAULT_TTS_VENDOR)
}

fn build_tts_language() -> String {
    String::from(DEFAULT_TTS_LANGUAGE)
}

fn build_tts_voice() -> String {
    String::from(DEFAULT_TTS_VOICE)
}

fn build_default_timezone() -> String {
    String::from(DEFAULT_TIMEZONE)
}

fn build_trunk_description() -> String {
    String::from(DEFAULT_TRUNK_DESCRIPTION)
}

fn build_trunk_port() -> u16 {
    DEFAULT_TRUNK_PORT
}

fn build_country_code() -> String {
    String::from(DEFAULT_COUNTRY_CODE)
}

fn build_logger() -> LoggerLevel {
    LoggerLevel::Warn
}

fn build_call_time() -> u16 {
    DEFAULT_CALL_TIME
}

fn build_ring_time() -> u8 {
    DEFAULT_RING_TIME
}

fn build_spend_cap_value() -> u16 {
    100
}

fn build_spend_cap_level() -> u8 {
    80
}

fn build_spend_cap_action() -> RouteAction {
    RouteAction::Warn
}

fn build_concurrency_action() -> RouteAction {
    RouteAction::Warn
}

fn build_cos_action() -> COSAction {
    COSAction::Allow
}

fn build_cos_ppm() -> f32 {
    15.00
}

fn build_cos_ppc() -> f32 {
    15.00
}

fn build_license() -> Licence {
    Licence::Standard
}

fn build_record_retention() -> String {
    String::from(DEFAULT_RECORDING_RETENTION)
}
// #[test]
// fn account_json() {
//     let file = File::open("./assets/account-data.json").expect("file should open read only");
//
//     let account: Account = serde_json::from_reader(file).expect("file should be proper JSON");
//
//     println!("{:#?}", account);
//
//     for dev in &account.devices {
//         if dev.is_connector() {
//             if dev.connect_to().ne("HANGUP") {
//                 let device = dev.connect(&account);
//                 assert_eq!(device.is_none(), false);
//             }
//         }
//     }
// }