cal-core 0.2.158

Callable core lib
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

use crate::device::device::{Connector, EndpointDevice};
use crate::{ConnectState, FlowState, NumberFormat, Region, VoiceServer};
use cal_jambonz::listen::Listen;
use serde::{Deserialize, Serialize};
use std::fmt::{Debug, Formatter};
use std::sync::Arc;
use crate::device::shared::{AiOptions, CallControl, RecordOptions, TranscribeOptions};

#[derive(Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Remote {
    #[serde(default = "crate::device::shared::build_destination")]
    pub destination: String,
    #[serde(default)]
    pub proxies: Vec<String>,
    #[serde(default = "crate::device::shared::build_present")]
    pub present: String,
    #[serde(default = "crate::device::shared::build_format")]
    pub format: NumberFormat,
    #[serde(default = "crate::device::shared::build_country_code")]
    pub country_code: String,
    #[serde(default = "crate::device::shared::build_connect_to")]
    pub on_complete: String,
    #[serde(default = "crate::device::shared::build_connect_to")]
    pub on_busy: String,
    #[serde(default = "crate::device::shared::build_connect_to")]
    pub on_fail: String,
    #[serde(default = "crate::device::shared::build_connect_to")]
    pub on_no_answer: String,
    #[serde(default = "crate::device::shared::build_ring_time")]
    pub ring_time: u8,
    #[serde(default = "crate::device::shared::build_call_time")]
    pub max_call_time: u16,
    #[serde(default)]
    pub transcribe_options: TranscribeOptions,
    #[serde(default)]
    pub record_options: RecordOptions,
    #[serde(default)]
    pub ai_options: AiOptions,
    #[serde(default)]
    pub call_control: CallControl,
}

impl Debug for Remote {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Remote")
            .field("destination", &self.destination)
            .field("proxies", &self.proxies)
            .field("present", &self.present)
            .field("format", &self.format)
            .field("country_code", &self.country_code)
            .field("on_complete", &self.on_complete)
            .field("on_busy", &self.on_busy)
            .field("on_fail", &self.on_fail)
            .field("on_no_answer", &self.on_no_answer)
            .field("ring_time", &self.ring_time)
            .field("max_call_time", &self.max_call_time)
            .field("transcribe_options", &self.transcribe_options)
            .field("record_options", &self.record_options)
            .field("ai_options", &self.ai_options)
            .field("call_control", &self.call_control)
            .finish()
    }
}

impl Connector for Remote {
    fn get_connect_to(&mut self, state: &mut FlowState) -> ConnectState {
        match &state.get_dial_status() {
            Some(status) => match status {
                cal_jambonz::shared::shared::SIPStatus::Ok => {
                    ConnectState::complete(self.on_complete.as_str())
                }
                cal_jambonz::shared::shared::SIPStatus::RequestTerminated => {
                    ConnectState::no_answer(self.on_no_answer.as_str())
                }
                cal_jambonz::shared::shared::SIPStatus::BusyHere | cal_jambonz::shared::shared::SIPStatus::BusyEverywhere => {
                    ConnectState::busy(self.on_busy.as_str())
                }
                _ => ConnectState::fail(self.on_fail.as_str()),
            },
            None => ConnectState::dialling(),
        }
    }
}

impl EndpointDevice for Remote {
    fn device_type_name(&self) -> &'static str {
        "Remote"
    }

    fn supports_routing(&self) -> bool {
        true
    }
}

impl crate::device::device::Endpoint for Remote {
    fn get_listen(&self, _state: &FlowState) -> Option<Listen> {
        None
    }

    fn get_proxy(&self, _state: &FlowState, _regions: Vec<Arc<Region>>) -> Option<VoiceServer> {
        None
    }
}