1use serde::{Deserialize, Serialize};
2use std::collections::HashMap;
3use std::fs::File;
4
5const HANG_UP_CONNECT: &str = "HANGUP";
6const DEFAULT_TTS_VOICE: &str = "en-GB-Standard-B";
7const DEFAULT_TTS_LANGUAGE: &str = "en-GB";
8const DEFAULT_TTS_VENDOR: &str = "google";
9const DEFAULT_ASR_LANGUAGE: &str = "en-GB";
10const DEFAULT_ASR_VENDOR: &str = "google";
11const DEFAULT_RECORDING_RETENTION: &str = "P30D";
12const DEFAULT_CLIENT_PROFILE: &str = "generic_e164_plus";
13const DEFAULT_COUNTRY_CODE: &str = "gb";
14const DEFAULT_DIGITS_FINISH_KEY: &str = "#";
15const DEFAULT_ENDPOINT_PRESENT: &str = "pass-through";
16const DEFAULT_VM_FINISH_KEY: &str = "#";
17const DEFAULT_ENDPOINT_FORMAT: &str = "e164p";
18const DEFAULT_TIMEZONE: &str = "Europe/London";
19const DEFAULT_TRUNK_DESCRIPTION: &str = "SIP Trunk";
20const DEFAULT_TRUNK_PORT: u16 = 5060;
21const DEFAULT_RING_TIME: u8 = 180;
22const DEFAULT_DIGIT_TIMEOUT: u8 = 10;
23const DEFAULT_MAX_DIGITS: u8 = 1;
24const DEFAULT_VM_TIMEOUT: u8 = 30;
25const DEFAULT_VM_MAX_LENGTH: u8 = 30;
26const DEFAULT_CALL_TIME: u16 = 14400;
27
28#[derive(Serialize, Deserialize, Debug)]
29#[serde(rename_all = "camelCase")]
30pub struct RecordReference {
31 id: String,
32 name: String,
33}
34
35#[derive(Serialize, Deserialize, Debug)]
36#[serde(rename_all = "camelCase")]
37pub struct Account {
38 id: String,
39 name: String,
40 mbn: String,
41 domain: String,
42 created: Option<String>,
44 organisation: RecordReference,
45 #[serde(default)]
46 ddis: Vec<DDI>,
47 #[serde(default)]
48 trunks: Vec<Trunk>,
49 #[serde(default)]
50 #[serde(rename = "callbackURLS")]
51 hooks: Vec<Hook>,
52 #[serde(default)]
53 devices: Vec<Device>,
54 #[serde(default)]
55 settings: Vec<Setting>,
56 #[serde(default)]
57 assets: Vec<Asset>,
58 #[serde(default)]
59 address: Address,
60 #[serde(default)]
61 teams: TeamsAccount,
62 #[serde(default)]
63 environment: Environment,
64 #[serde(default)]
65 spend_cap: SpendCap,
66 concurrency: Concurrency,
67 #[serde(default)]
68 class_of_service: ClassOfService,
69 #[serde(default)]
70 api_keys: APIKeys,
71 cluster_settings: Cluster,
72 domain_settings: Domain,
73}
74
75#[derive(Serialize, Deserialize, Debug)]
76#[serde(rename_all = "camelCase")]
77pub struct Cluster {
78 id: String,
79 name: String,
80 router: RecordReference,
81}
82
83#[derive(Serialize, Deserialize, Debug)]
84#[serde(rename_all = "camelCase")]
85pub struct Domain {
86 #[serde(rename = "serverA")]
87 server_a: String,
88 #[serde(rename = "serverB")]
89 server_b: String,
90}
91
92#[derive(Serialize, Deserialize, Debug)]
93#[serde(rename_all = "camelCase")]
94pub struct APIKeys {
95 #[serde(default)]
96 keys: Vec<APIKey>,
97}
98
99impl Default for APIKeys {
100 fn default() -> Self {
101 Self { keys: Vec::new() }
102 }
103}
104
105#[derive(Serialize, Deserialize, Debug)]
106#[serde(rename_all = "camelCase")]
107pub struct APIKey {
108 key: String,
109}
110
111#[derive(Serialize, Deserialize, Debug)]
112#[serde(rename_all = "camelCase")]
113pub struct Environment {
114 #[serde(default = "build_logger")]
115 logger: LoggerLevel,
116 #[serde(rename = "dialTimeLimit")]
117 #[serde(default = "build_call_time")]
118 max_call_time: u16,
119 #[serde(rename = "dialTimeout")]
120 #[serde(default = "build_ring_time")]
121 ring_time: u8,
122 #[serde(default = "build_tts_vendor")]
123 tts_vendor: String,
124 #[serde(default = "build_tts_language")]
125 #[serde(rename = "ttsLanguageV2")]
126 tts_language: String,
127 #[serde(default = "build_tts_voice")]
128 tts_voice: String,
129 #[serde(default = "build_asr_vendor")]
130 asr_vendor: String,
131 #[serde(default = "build_asr_language")]
132 asr_language: String,
133 #[serde(default = "build_default_timezone")]
134 time_zone: String,
135 #[serde(default = "build_country_code")]
136 country_code: String,
137 #[serde(default = "build_record_retention")]
138 recording_retention: String,
139 ingress_script: Option<String>,
140}
141
142impl Default for Environment {
143 fn default() -> Self {
144 Self {
145 logger: LoggerLevel::Warn,
146 max_call_time: DEFAULT_CALL_TIME,
147 ring_time: DEFAULT_RING_TIME,
148 tts_vendor: DEFAULT_TTS_VENDOR.to_string(),
149 tts_language: DEFAULT_TTS_LANGUAGE.to_string(),
150 tts_voice: DEFAULT_TTS_VOICE.to_string(),
151 asr_vendor: DEFAULT_ASR_VENDOR.to_string(),
152 asr_language: DEFAULT_ASR_LANGUAGE.to_string(),
153 time_zone: DEFAULT_TIMEZONE.to_string(),
154 country_code: DEFAULT_COUNTRY_CODE.to_string(),
155 recording_retention: DEFAULT_RECORDING_RETENTION.to_string(),
156 ingress_script: None,
157 }
158 }
159}
160
161#[derive(Serialize, Deserialize, Debug)]
162#[serde(rename_all = "camelCase")]
163pub struct SpendCap {
164 #[serde(default = "build_spend_cap_value")]
165 value: u16,
166 #[serde(default = "build_spend_cap_level")]
167 warn: u8,
168 #[serde(default = "build_spend_cap_action")]
169 action: RouteAction,
170 #[serde(default)]
171 email_recipients: Vec<String>,
172}
173
174impl Default for SpendCap {
175 fn default() -> Self {
176 Self {
177 value: 100,
178 warn: 80,
179 action: RouteAction::Warn,
180 email_recipients: Vec::new(),
181 }
182 }
183}
184
185#[derive(Serialize, Deserialize, Debug)]
186#[serde(rename_all = "camelCase")]
187pub struct Concurrency {
188 #[serde(rename = "type")]
189 #[serde(default = "build_license")]
190 license: Licence,
191 #[serde(default = "build_concurrency_action")]
192 action: RouteAction,
193 #[serde(default)]
194 email_recipients: Vec<String>,
195}
196
197#[derive(Serialize, Deserialize, Debug)]
198#[serde(rename_all = "camelCase")]
199pub struct ClassOfService {
200 #[serde(rename = "type")]
201 #[serde(default = "build_cos_action")]
202 license: COSAction,
203 #[serde(default)]
204 countries: Vec<String>,
205 #[serde(default)]
206 prefix_exceptions: String,
207 #[serde(rename = "maxPPM")]
208 #[serde(default = "build_cos_ppm")]
209 max_ppm: f32,
210 #[serde(rename = "maxPPC")]
211 #[serde(default = "build_cos_ppc")]
212 max_ppc: f32,
213}
214
215impl Default for ClassOfService {
216 fn default() -> Self {
217 Self {
218 license: COSAction::Allow,
219 countries: Vec::new(),
220 prefix_exceptions: String::from(""),
221 max_ppc: 10.00,
222 max_ppm: 10.00,
223 }
224 }
225}
226
227#[derive(Serialize, Deserialize, Debug)]
228pub enum LoggerLevel {
229 #[serde(rename = "info")]
230 Info,
231 #[serde(rename = "warn")]
232 Warn,
233 #[serde(rename = "error")]
234 Error,
235}
236
237#[derive(Serialize, Deserialize, Debug)]
238pub enum Licence {
239 #[serde(rename = "standard")]
240 Standard,
241 #[serde(rename = "professional")]
242 Professional,
243 #[serde(rename = "enterprise")]
244 Enterprise,
245}
246
247#[derive(Serialize, Deserialize, Debug)]
248pub enum COSAction {
249 #[serde(rename = "DENY")]
250 Deny,
251 #[serde(rename = "ALLOW")]
252 Allow,
253}
254
255#[derive(Serialize, Deserialize, Debug)]
256pub enum RouteAction {
257 #[serde(rename = "warn")]
258 Warn,
259 #[serde(rename = "restrict")]
260 Restrict,
261 #[serde(rename = "deny")]
262 Deny,
263}
264
265#[derive(Serialize, Deserialize, Debug)]
266#[serde(rename_all = "camelCase")]
267pub struct TeamsAccount {
268 #[serde(rename = "type")]
269 domain_type: String,
270 #[serde(default)]
271 domain: String,
272 txt: Option<String>,
273 #[serde(rename = "serverA")]
274 server_a: String,
275 #[serde(rename = "serverB")]
276 server_b: String,
277}
278
279impl Default for TeamsAccount {
280 fn default() -> Self {
281 Self {
282 domain_type: String::from("callable"),
283 domain: String::from(""),
284 server_a: String::from(""),
285 server_b: String::from(""),
286 txt: None,
287 }
288 }
289}
290
291#[derive(Serialize, Deserialize, Debug)]
292#[serde(rename_all = "camelCase")]
293pub struct Address {
294 #[serde(default)]
295 line1: String,
296 #[serde(default)]
297 line2: String,
298 #[serde(default)]
299 level1: String,
300 #[serde(default)]
301 level2: String,
302 #[serde(default)]
303 postal_code: String,
304 #[serde(default)]
305 country: String,
306}
307
308impl Default for Address {
309 fn default() -> Self {
310 Self {
311 line1: String::from(""),
312 line2: String::from(""),
313 level1: String::from(""),
314 level2: String::from(""),
315 postal_code: String::from(""),
316 country: String::from(""),
317 }
318 }
319}
320
321#[derive(Serialize, Deserialize, Debug)]
322#[serde(rename_all = "camelCase")]
323pub struct Asset {
324 id: String,
325 bucket: String,
326 key: String,
327 filename: String,
328 name: String,
329 mime_type: String,
330 size: u32,
331 created: String,
332 #[serde(default)]
333 meta: HashMap<String, String>,
334}
335
336#[derive(Serialize, Deserialize, Debug)]
337#[serde(rename_all = "camelCase")]
338pub struct Setting {
339 #[serde(default)]
340 id: String,
341 key: String,
342 #[serde(rename = "type")]
343 setting_type: String,
344 value: String,
345}
346
347#[derive(Serialize, Deserialize, Debug)]
348#[serde(rename_all = "camelCase")]
349pub struct DDI {
350 id: String,
351 name: String,
352 #[serde(default)]
353 meta: HashMap<String, String>,
354}
355
356#[derive(Serialize, Deserialize, Debug)]
357#[serde(rename_all = "camelCase")]
358pub struct Trunk {
359 id: String,
360 ip: String,
361 #[serde(default = "build_trunk_description")]
362 description: String,
363 #[serde(default = "build_trunk_port")]
364 port: u16,
365}
366
367#[derive(Serialize, Deserialize, Debug)]
368#[serde(rename_all = "camelCase")]
369pub struct Hook {
370 id: String,
371 app: String,
372 url: String,
373 #[serde(default = "AuthType::default_method")]
374 auth_type: AuthType,
375 #[serde(default = "HookMethod::default_method")]
376 method: HookMethod,
377 #[serde(default)]
378 meta: HashMap<String, String>,
379 #[serde(default)]
380 api_key_name: String,
381 #[serde(default)]
382 api_key_value: String,
383 #[serde(default)]
384 api_secret_name: String,
385 #[serde(default)]
386 api_secret_value: String,
387}
388
389#[derive(Serialize, Deserialize, Debug)]
390pub enum HookMethod {
391 #[serde(rename = "POST")]
392 Post,
393 #[serde(rename = "GET")]
394 Get,
395}
396
397#[derive(Serialize, Deserialize, Debug)]
398pub enum QueueItemType {
399 #[serde(rename = "play")]
400 Play,
401 #[serde(rename = "say")]
402 Say,
403 #[serde(rename = "pause")]
404 Pause,
405}
406
407impl HookMethod {
408 fn default_method() -> Self {
409 HookMethod::Post
410 }
411}
412
413#[derive(Serialize, Deserialize, Debug)]
414pub enum AuthType {
415 #[serde(rename = "DISABLED")]
416 Disabled,
417 #[serde(rename = "KEY")]
418 Key,
419 #[serde(rename = "KEY_SECRET")]
420 KeySecret,
421 #[serde(rename = "BASIC_AUTH")]
422 BasicAuth,
423}
424
425impl AuthType {
426 fn default_method() -> Self {
427 AuthType::Disabled
428 }
429}
430
431#[derive(Serialize, Deserialize, Debug)]
432#[serde(untagged)]
433pub enum Device {
434 InboundFlow(InboundFlowStruct),
435 OutboundFlow(OutboundFlowStruct),
436 WhatsAppFlow(WhatsAppFlowStruct),
437 AppFlow(AppFlowStruct),
438 AniRouter(AniRouterStruct),
439 DnisRouter(DnisRouterStruct),
440 DigitRouter(DigitRouterStruct),
441 TimeRangeRouter(TimeRangeRouterStruct),
442 DayOfWeekRouter(DayOfWeekRouterStruct),
443 DateRangeRouter(DateRangeRouterStruct),
444 HuntGroup(HuntGroupStruct),
445 Client(ClientStruct),
446 Teams(TeamsStruct),
447 SipExtension(SipExtensionStruct),
448 SipGateway(SipGatewayStruct),
449 Remote(RemoteStruct),
450 Plugin(PluginStruct),
451 Play(PlayStruct),
452 Say(SayStruct),
453 Voicemail(VoiceMailStruct),
454 Script(ScriptStruct),
455 Queue(QueueStruct),
456 Sms(SmsStruct),
457 Email(EmailStruct),
458 Tag(TagStruct),
459 TagRouter(TagRouterStruct),
460 MessagePlugin(MessagePluginStruct),
461 MessageText(MessageTextStruct),
462 Service(ServiceStruct),
463}
464
465impl Device {
466 fn get_id(&self) -> String {
467 match self {
468 Device::InboundFlow(value) => value.id.clone(),
469 Device::OutboundFlow(value) => value.id.clone(),
470 Device::AppFlow(value) => value.id.clone(),
471 Device::WhatsAppFlow(value) => value.id.clone(),
472 Device::AniRouter(value) => value.id.clone(),
473 Device::DnisRouter(value) => value.id.clone(),
474 Device::DigitRouter(value) => value.id.clone(),
475 Device::TimeRangeRouter(value) => value.id.clone(),
476 Device::DayOfWeekRouter(value) => value.id.clone(),
477 Device::DateRangeRouter(value) => value.id.clone(),
478 Device::HuntGroup(value) => value.id.clone(),
479 Device::Client(value) => value.id.clone(),
480 Device::Teams(value) => value.id.clone(),
481 Device::SipExtension(value) => value.id.clone(),
482 Device::SipGateway(value) => value.id.clone(),
483 Device::Remote(value) => value.id.clone(),
484 Device::Plugin(value) => value.id.clone(),
485 Device::Play(value) => value.id.clone(),
486 Device::Say(value) => value.id.clone(),
487 Device::Voicemail(value) => value.id.clone(),
488 Device::Script(value) => value.id.clone(),
489 Device::Queue(value) => value.id.clone(),
490 Device::Sms(value) => value.id.clone(),
491 Device::Email(value) => value.id.clone(),
492 Device::Tag(value) => value.id.clone(),
493 Device::TagRouter(value) => value.id.clone(),
494 Device::MessagePlugin(value) => value.id.clone(),
495 Device::MessageText(value) => value.id.clone(),
496 Device::Service(value) => value.id.clone(),
497 }
498 }
499
500 fn is_connector(&self) -> bool {
501 match self {
502 Device::InboundFlow(_value) => true,
503 Device::OutboundFlow(_value) => true,
504 Device::AppFlow(_value) => true,
505 Device::WhatsAppFlow(_value) => true,
506 Device::AniRouter(_value) => true,
507 Device::DnisRouter(_value) => true,
508 Device::DigitRouter(_value) => true,
509 Device::TimeRangeRouter(_value) => true,
510 Device::DayOfWeekRouter(_value) => true,
511 Device::DateRangeRouter(_value) => true,
512 Device::Play(_value) => true,
513 Device::Say(_value) => true,
514 Device::Voicemail(_value) => true,
515 Device::Script(_value) => true,
516 Device::Queue(_value) => true,
517 Device::Sms(_value) => true,
518 Device::Email(_value) => true,
519 Device::Tag(_value) => true,
520 Device::TagRouter(_value) => true,
521 Device::Service(_value) => true,
522 Device::HuntGroup(_value) => false,
523 Device::Client(_value) => false,
524 Device::Teams(_value) => false,
525 Device::SipExtension(_value) => false,
526 Device::SipGateway(_value) => false,
527 Device::Remote(_value) => false,
528 Device::Plugin(_value) => false,
529 Device::MessagePlugin(_value) => false,
530 Device::MessageText(_value) => false,
531 }
532 }
533
534 fn is_call_handler(&self) -> bool {
535 match self {
536 Device::InboundFlow(_value) => false,
537 Device::OutboundFlow(_value) => false,
538 Device::AppFlow(_value) => false,
539 Device::WhatsAppFlow(_value) => false,
540 Device::AniRouter(_value) => false,
541 Device::DnisRouter(_value) => false,
542 Device::DigitRouter(_value) => false,
543 Device::TimeRangeRouter(_value) => false,
544 Device::DayOfWeekRouter(_value) => false,
545 Device::DateRangeRouter(_value) => false,
546 Device::Play(_value) => false,
547 Device::Say(_value) => false,
548 Device::Voicemail(_value) => false,
549 Device::Script(_value) => false,
550 Device::Queue(_value) => false,
551 Device::Sms(_value) => false,
552 Device::Email(_value) => false,
553 Device::Tag(_value) => false,
554 Device::TagRouter(_value) => false,
555 Device::Service(_value) => false,
556 Device::HuntGroup(_value) => true,
557 Device::Client(_value) => true,
558 Device::Teams(_value) => true,
559 Device::SipExtension(_value) => true,
560 Device::SipGateway(_value) => true,
561 Device::Remote(_value) => true,
562 Device::Plugin(_value) => true,
563 Device::MessagePlugin(_value) => true,
564 Device::MessageText(_value) => true,
565 }
566 }
567
568 fn connect_to(&self) -> String {
569 match self {
570 Device::InboundFlow(value) => value.value.connect_to.clone(),
571 Device::OutboundFlow(value) => value.value.connect_to.clone(),
572 Device::AppFlow(value) => value.value.connect_to.clone(),
573 Device::WhatsAppFlow(value) => value.value.connect_to.clone(),
574 Device::AniRouter(value) => value.value.connect_to.clone(),
575 Device::DnisRouter(value) => value.value.connect_to.clone(),
576 Device::DigitRouter(value) => value.value.connect_to.clone(),
577 Device::TimeRangeRouter(value) => value.value.connect_to.clone(),
578 Device::DayOfWeekRouter(value) => value.value.connect_to.clone(),
579 Device::DateRangeRouter(value) => value.value.connect_to.clone(),
580 Device::Play(value) => value.value.connect_to.clone(),
581 Device::Say(value) => value.value.connect_to.clone(),
582 Device::Voicemail(value) => value.value.connect_to.clone(),
583 Device::Script(value) => value.value.connect_to.clone(),
584 Device::Queue(value) => value.value.connect_to.clone(),
585 Device::Sms(value) => value.value.connect_to.clone(),
586 Device::Email(value) => value.value.connect_to.clone(),
587 Device::Tag(value) => value.value.connect_to.clone(),
588 Device::TagRouter(value) => value.value.connect_to.clone(),
589 Device::Service(value) => value.value.connect_to.clone(),
590 _ => String::from(HANG_UP_CONNECT),
591 }
592 }
593
594 fn on_busy(&self) -> String {
595 match self {
596 Device::Plugin(value) => value.value.on_busy.clone(),
597 Device::HuntGroup(value) => value.value.on_busy.clone(),
598 Device::Client(value) => value.value.on_busy.clone(),
599 Device::Teams(value) => value.value.on_busy.clone(),
600 Device::SipExtension(value) => value.value.on_busy.clone(),
601 Device::SipGateway(value) => value.value.on_busy.clone(),
602 Device::Remote(value) => value.value.on_busy.clone(),
603 _ => String::from(HANG_UP_CONNECT),
604 }
605 }
606
607 fn on_complete(&self) -> String {
608 match self {
609 Device::Plugin(value) => value.value.on_complete.clone(),
610 Device::HuntGroup(value) => value.value.on_complete.clone(),
611 Device::Client(value) => value.value.on_complete.clone(),
612 Device::Teams(value) => value.value.on_complete.clone(),
613 Device::SipExtension(value) => value.value.on_complete.clone(),
614 Device::SipGateway(value) => value.value.on_complete.clone(),
615 Device::Remote(value) => value.value.on_complete.clone(),
616 _ => String::from(HANG_UP_CONNECT),
617 }
618 }
619
620 fn on_no_answer(&self) -> String {
621 match self {
622 Device::Plugin(value) => value.value.on_no_answer.clone(),
623 Device::HuntGroup(value) => value.value.on_no_answer.clone(),
624 Device::Client(value) => value.value.on_no_answer.clone(),
625 Device::Teams(value) => value.value.on_no_answer.clone(),
626 Device::SipExtension(value) => value.value.on_no_answer.clone(),
627 Device::SipGateway(value) => value.value.on_no_answer.clone(),
628 Device::Remote(value) => value.value.on_no_answer.clone(),
629 _ => String::from(HANG_UP_CONNECT),
630 }
631 }
632
633 fn on_fail(&self) -> String {
634 match self {
635 Device::Plugin(value) => value.value.on_fail.clone(),
636 Device::HuntGroup(value) => value.value.on_fail.clone(),
637 Device::Client(value) => value.value.on_fail.clone(),
638 Device::Teams(value) => value.value.on_fail.clone(),
639 Device::SipExtension(value) => value.value.on_fail.clone(),
640 Device::SipGateway(value) => value.value.on_fail.clone(),
641 Device::Remote(value) => value.value.on_fail.clone(),
642 _ => String::from(HANG_UP_CONNECT),
643 }
644 }
645
646 fn on_transfer(&self) -> String {
647 match self {
648 Device::Plugin(value) => value.value.on_transfer.clone(),
649 _ => String::from(HANG_UP_CONNECT),
650 }
651 }
652
653 fn on_error(&self) -> String {
654 match self {
655 Device::Plugin(value) => value.value.on_error.clone(),
656 _ => String::from(HANG_UP_CONNECT),
657 }
658 }
659
660 fn connect<'a>(&'a self, account: &'a Account) -> Option<&Device> {
661 if account.devices.len() == 0 {
662 return None;
663 }
664 let con: String = String::from(self.connect_to());
665 if con.eq(HANG_UP_CONNECT) {
666 return None;
667 }
668 let mut device = None;
669 account.devices.iter().for_each(|d| {
670 if d.get_id().eq(&con) {
671 device = Some(d);
672 }
673 });
674 device
675 }
676}
677
678#[derive(Serialize, Deserialize, Debug)]
679pub struct InboundFlowStruct {
680 id: String,
681 name: String,
682 extension: u16,
683 #[serde(default)]
684 tags: Vec<DeviceTag>,
685 #[serde(rename = "startRoute")]
686 value: InboundFlow,
687}
688
689#[derive(Serialize, Deserialize, Debug)]
690pub struct OutboundFlowStruct {
691 id: String,
692 name: String,
693 extension: u16,
694 #[serde(default)]
695 tags: Vec<DeviceTag>,
696 #[serde(rename = "regexRoute")]
697 value: OutboundFlow,
698}
699
700#[derive(Serialize, Deserialize, Debug)]
701pub struct WhatsAppFlowStruct {
702 id: String,
703 name: String,
704 extension: u16,
705 #[serde(default)]
706 tags: Vec<DeviceTag>,
707 #[serde(rename = "whatsAppRoute")]
708 value: WhatsAppFlow,
709}
710
711#[derive(Serialize, Deserialize, Debug)]
712pub struct AppFlowStruct {
713 id: String,
714 name: String,
715 extension: u16,
716 #[serde(default)]
717 tags: Vec<DeviceTag>,
718 #[serde(rename = "appRoute")]
719 value: AppFlow,
720}
721
722#[derive(Serialize, Deserialize, Debug)]
723pub struct AniRouterStruct {
724 id: String,
725 name: String,
726 extension: u16,
727 #[serde(default)]
728 tags: Vec<DeviceTag>,
729 #[serde(rename = "aniRouter")]
730 value: ANIRouter,
731}
732
733#[derive(Serialize, Deserialize, Debug)]
734pub struct DnisRouterStruct {
735 id: String,
736 name: String,
737 extension: u16,
738 #[serde(default)]
739 tags: Vec<DeviceTag>,
740 #[serde(rename = "dnisRouter")]
741 value: ANIRouter,
742}
743
744#[derive(Serialize, Deserialize, Debug)]
745pub struct DigitRouterStruct {
746 id: String,
747 name: String,
748 extension: u16,
749 #[serde(default)]
750 tags: Vec<DeviceTag>,
751 #[serde(rename = "numberPlan")]
752 value: DigitRouter,
753}
754
755#[derive(Serialize, Deserialize, Debug)]
756pub struct TimeRangeRouterStruct {
757 id: String,
758 name: String,
759 extension: u16,
760 #[serde(default)]
761 tags: Vec<DeviceTag>,
762 #[serde(rename = "timeRangeRoute")]
763 value: TimeRangeRouter,
764}
765
766#[derive(Serialize, Deserialize, Debug)]
767pub struct DayOfWeekRouterStruct {
768 id: String,
769 name: String,
770 extension: u16,
771 #[serde(default)]
772 tags: Vec<DeviceTag>,
773 #[serde(rename = "dayOfWeekRoute")]
774 value: DayOfWeekRouter,
775}
776
777#[derive(Serialize, Deserialize, Debug)]
778pub struct DateRangeRouterStruct {
779 id: String,
780 name: String,
781 extension: u16,
782 #[serde(default)]
783 tags: Vec<DeviceTag>,
784 #[serde(rename = "dateRangeRoute")]
785 value: DateRangeRouter,
786}
787
788#[derive(Serialize, Deserialize, Debug)]
789pub struct HuntGroupStruct {
790 id: String,
791 name: String,
792 extension: u16,
793 #[serde(default)]
794 tags: Vec<DeviceTag>,
795 #[serde(rename = "huntGroup")]
796 value: HuntGroup,
797}
798
799#[derive(Serialize, Deserialize, Debug)]
800pub struct ClientStruct {
801 id: String,
802 name: String,
803 extension: u16,
804 #[serde(default)]
805 tags: Vec<DeviceTag>,
806 #[serde(rename = "client")]
807 value: Client,
808}
809
810#[derive(Serialize, Deserialize, Debug)]
811pub struct TeamsStruct {
812 id: String,
813 name: String,
814 extension: u16,
815 #[serde(default)]
816 tags: Vec<DeviceTag>,
817 #[serde(rename = "teams")]
818 value: Teams,
819}
820
821#[derive(Serialize, Deserialize, Debug)]
822pub struct SipExtensionStruct {
823 id: String,
824 name: String,
825 extension: u16,
826 #[serde(default)]
827 tags: Vec<DeviceTag>,
828 #[serde(rename = "sipExtension")]
829 value: SipExtension,
830}
831
832#[derive(Serialize, Deserialize, Debug)]
833pub struct SipGatewayStruct {
834 id: String,
835 name: String,
836 extension: u16,
837 #[serde(default)]
838 tags: Vec<DeviceTag>,
839 #[serde(rename = "sipGateway")]
840 value: SipGateway,
841}
842
843#[derive(Serialize, Deserialize, Debug)]
844pub struct RemoteStruct {
845 id: String,
846 name: String,
847 extension: u16,
848 #[serde(default)]
849 tags: Vec<DeviceTag>,
850 #[serde(rename = "remote")]
851 value: Remote,
852}
853
854#[derive(Serialize, Deserialize, Debug)]
855pub struct PluginStruct {
856 id: String,
857 name: String,
858 extension: u16,
859 #[serde(default)]
860 tags: Vec<DeviceTag>,
861 #[serde(rename = "plugin")]
862 value: Plugin,
863}
864
865#[derive(Serialize, Deserialize, Debug)]
866pub struct PlayStruct {
867 id: String,
868 name: String,
869 extension: u16,
870 #[serde(default)]
871 tags: Vec<DeviceTag>,
872 #[serde(rename = "play")]
873 value: Play,
874}
875
876#[derive(Serialize, Deserialize, Debug)]
877pub struct SayStruct {
878 id: String,
879 name: String,
880 extension: u16,
881 #[serde(default)]
882 tags: Vec<DeviceTag>,
883 #[serde(rename = "say")]
884 value: Say,
885}
886
887#[derive(Serialize, Deserialize, Debug)]
888pub struct VoiceMailStruct {
889 id: String,
890 name: String,
891 extension: u16,
892 #[serde(default)]
893 tags: Vec<DeviceTag>,
894 #[serde(rename = "voicemail")]
895 value: VoiceMail,
896}
897
898#[derive(Serialize, Deserialize, Debug)]
899pub struct ScriptStruct {
900 id: String,
901 name: String,
902 extension: u16,
903 #[serde(default)]
904 tags: Vec<DeviceTag>,
905 #[serde(rename = "script")]
906 value: Script,
907}
908
909#[derive(Serialize, Deserialize, Debug)]
910pub struct QueueStruct {
911 id: String,
912 name: String,
913 extension: u16,
914 #[serde(default)]
915 tags: Vec<DeviceTag>,
916 #[serde(rename = "queue")]
917 value: Queue,
918}
919
920#[derive(Serialize, Deserialize, Debug)]
921pub struct SmsStruct {
922 id: String,
923 name: String,
924 extension: u16,
925 #[serde(default)]
926 tags: Vec<DeviceTag>,
927 #[serde(rename = "sms")]
928 value: Sms,
929}
930
931#[derive(Serialize, Deserialize, Debug)]
932pub struct EmailStruct {
933 id: String,
934 name: String,
935 extension: u16,
936 #[serde(default)]
937 tags: Vec<DeviceTag>,
938 #[serde(rename = "email")]
939 value: Email,
940}
941
942#[derive(Serialize, Deserialize, Debug)]
943pub struct TagStruct {
944 id: String,
945 name: String,
946 extension: u16,
947 #[serde(default)]
948 tags: Vec<DeviceTag>,
949 #[serde(rename = "tag")]
950 value: Tag,
951}
952
953#[derive(Serialize, Deserialize, Debug)]
954pub struct TagRouterStruct {
955 id: String,
956 name: String,
957 extension: u16,
958 #[serde(default)]
959 tags: Vec<DeviceTag>,
960 #[serde(rename = "tagRouter")]
961 value: TagRouter,
962}
963
964#[derive(Serialize, Deserialize, Debug)]
965pub struct MessagePluginStruct {
966 id: String,
967 name: String,
968 extension: u16,
969 #[serde(default)]
970 tags: Vec<DeviceTag>,
971 #[serde(rename = "messagePlugin")]
972 value: MessagePlugin,
973}
974
975#[derive(Serialize, Deserialize, Debug)]
976pub struct MessageTextStruct {
977 id: String,
978 name: String,
979 extension: u16,
980 #[serde(default)]
981 tags: Vec<DeviceTag>,
982 #[serde(rename = "messageText")]
983 value: MessageText,
984}
985
986#[derive(Serialize, Deserialize, Debug)]
987pub struct ServiceStruct {
988 id: String,
989 name: String,
990 extension: u16,
991 #[serde(default)]
992 tags: Vec<DeviceTag>,
993 #[serde(rename = "service")]
994 value: Service,
995}
996
997#[derive(Serialize, Deserialize, Debug)]
998#[serde(rename_all = "camelCase")]
999pub struct DeviceTag {
1000 #[serde(rename = "type")]
1001 tag_type: String,
1002 name: String,
1003 value: String,
1004}
1005
1006#[derive(Serialize, Deserialize, Debug)]
1007#[serde(rename_all = "camelCase")]
1008pub struct InboundFlow {
1009 #[serde(default)]
1010 ddis: Vec<String>,
1011 #[serde(default = "build_connect_to")]
1012 connect_to: String,
1013}
1014
1015#[derive(Serialize, Deserialize, Debug)]
1016#[serde(rename_all = "camelCase")]
1017pub struct OutboundFlow {
1018 reg_exp: String,
1019 #[serde(default = "build_connect_to")]
1020 connect_to: String,
1021}
1022
1023#[derive(Serialize, Deserialize, Debug)]
1024#[serde(rename_all = "camelCase")]
1025pub struct WhatsAppFlow {
1026 #[serde(default)]
1027 ddis: Vec<String>,
1028 #[serde(default = "build_connect_to")]
1029 connect_to: String,
1030}
1031
1032#[derive(Serialize, Deserialize, Debug)]
1033#[serde(rename_all = "camelCase")]
1034pub struct AppFlow {
1035 #[serde(default = "build_connect_to")]
1036 connect_to: String,
1037}
1038
1039#[derive(Serialize, Deserialize, Debug)]
1040#[serde(rename_all = "camelCase")]
1041pub struct ANIRouter {
1042 #[serde(default)]
1043 options: Vec<RouterOption>,
1044 #[serde(default = "build_connect_to")]
1045 connect_to: String,
1046}
1047
1048#[derive(Serialize, Deserialize, Debug)]
1049#[serde(rename_all = "camelCase")]
1050pub struct DNISRouter {
1051 #[serde(default)]
1052 options: Vec<RouterOption>,
1053 #[serde(default = "build_connect_to")]
1054 connect_to: String,
1055}
1056
1057#[derive(Serialize, Deserialize, Debug)]
1058#[serde(rename_all = "camelCase")]
1059pub struct DigitRouter {
1060 text: String,
1061 #[serde(rename = "ttsLanguage")]
1062 #[serde(default = "build_tts_voice")]
1063 tts_voice: String,
1064 #[serde(default = "build_finish_key")]
1065 finish_on_key: String,
1066 #[serde(default = "build_connect_to")]
1067 connect_to: String,
1068 #[serde(default)]
1069 options: Vec<RouterOption>,
1070 #[serde(default = "build_digit_timeout")]
1071 timeout: u8,
1072 #[serde(default = "build_max_digits")]
1073 max_digits: u8,
1074}
1075
1076#[derive(Serialize, Deserialize, Debug)]
1077#[serde(rename_all = "camelCase")]
1078pub struct HuntGroup {
1079 #[serde(default = "build_present")]
1080 present: String,
1081 #[serde(default = "build_country_code")]
1082 country_code: String,
1083 #[serde(default = "build_connect_to")]
1084 on_complete: String,
1085 #[serde(default = "build_connect_to")]
1086 on_busy: String,
1087 #[serde(default = "build_connect_to")]
1088 on_fail: String,
1089 #[serde(default = "build_connect_to")]
1090 on_no_answer: String,
1091 #[serde(default = "build_ring_time")]
1092 ring_time: u8,
1093 #[serde(default = "build_call_time")]
1094 max_call_time: u16,
1095 #[serde(default)]
1096 transcribe_options: TranscribeOptions,
1097 #[serde(default)]
1098 record_options: RecordOptions,
1099 #[serde(default)]
1100 devices: Vec<String>,
1101}
1102
1103#[derive(Serialize, Deserialize, Debug)]
1104#[serde(rename_all = "camelCase")]
1105pub struct Client {
1106 username: String,
1107 password: String,
1108 #[serde(default = "build_client_profile")]
1109 profile: String,
1110 user: Option<RecordReference>,
1111 #[serde(default = "build_format")]
1112 format: String,
1113 #[serde(default = "build_present")]
1114 present: String,
1115 #[serde(default = "build_country_code")]
1116 country_code: String,
1117 #[serde(default = "build_connect_to")]
1118 on_complete: String,
1119 #[serde(default = "build_connect_to")]
1120 on_busy: String,
1121 #[serde(default = "build_connect_to")]
1122 on_fail: String,
1123 #[serde(default = "build_connect_to")]
1124 on_no_answer: String,
1125 #[serde(default = "build_ring_time")]
1126 ring_time: u8,
1127 #[serde(default = "build_call_time")]
1128 max_call_time: u16,
1129 #[serde(default)]
1130 transcribe_options: TranscribeOptions,
1131 #[serde(default)]
1132 record_options: RecordOptions,
1133}
1134
1135#[derive(Serialize, Deserialize, Debug)]
1136#[serde(rename_all = "camelCase")]
1137pub struct Teams {
1138 to: String,
1139 #[serde(default = "build_present")]
1140 present: String,
1141 #[serde(default = "build_country_code")]
1142 country_code: String,
1143 #[serde(default = "build_connect_to")]
1144 on_complete: String,
1145 #[serde(default = "build_connect_to")]
1146 on_busy: String,
1147 #[serde(default = "build_connect_to")]
1148 on_fail: String,
1149 #[serde(default = "build_connect_to")]
1150 on_no_answer: String,
1151 #[serde(default = "build_ring_time")]
1152 ring_time: u8,
1153 #[serde(default = "build_call_time")]
1154 max_call_time: u16,
1155 #[serde(default)]
1156 transcribe_options: TranscribeOptions,
1157 #[serde(default)]
1158 record_options: RecordOptions,
1159}
1160
1161#[derive(Serialize, Deserialize, Debug)]
1162#[serde(rename_all = "camelCase")]
1163pub struct SipExtension {
1164 gateway: String,
1165 #[serde(default = "build_present")]
1166 present: String,
1167 #[serde(default = "build_country_code")]
1168 country_code: String,
1169 #[serde(default = "build_connect_to")]
1170 on_complete: String,
1171 #[serde(default = "build_connect_to")]
1172 on_busy: String,
1173 #[serde(default = "build_connect_to")]
1174 on_fail: String,
1175 #[serde(default = "build_connect_to")]
1176 on_no_answer: String,
1177 #[serde(default = "build_ring_time")]
1178 ring_time: u8,
1179 #[serde(default = "build_call_time")]
1180 max_call_time: u16,
1181 #[serde(default)]
1182 transcribe_options: TranscribeOptions,
1183 #[serde(default)]
1184 record_options: RecordOptions,
1185}
1186
1187#[derive(Serialize, Deserialize, Debug)]
1188#[serde(rename_all = "camelCase")]
1189pub struct SipGateway {
1190 #[serde(default = "build_format")]
1191 format: String,
1192 #[serde(default)]
1193 trunks: Vec<String>,
1194 #[serde(default)]
1195 proxies: Vec<String>,
1196 #[serde(default = "build_present")]
1197 present: String,
1198 #[serde(default = "build_country_code")]
1199 country_code: String,
1200 #[serde(default = "build_connect_to")]
1201 on_complete: String,
1202 #[serde(default = "build_connect_to")]
1203 on_busy: String,
1204 #[serde(default = "build_connect_to")]
1205 on_fail: String,
1206 #[serde(default = "build_connect_to")]
1207 on_no_answer: String,
1208 #[serde(default = "build_ring_time")]
1209 ring_time: u8,
1210 #[serde(default = "build_call_time")]
1211 max_call_time: u16,
1212 #[serde(default)]
1213 transcribe_options: TranscribeOptions,
1214 #[serde(default)]
1215 record_options: RecordOptions,
1216}
1217
1218#[derive(Serialize, Deserialize, Debug)]
1219#[serde(rename_all = "camelCase")]
1220pub struct Remote {
1221 destination: String,
1222 #[serde(default)]
1223 proxies: Option<Vec<String>>,
1224 #[serde(default = "build_present")]
1225 present: String,
1226 #[serde(default = "build_country_code")]
1227 country_code: String,
1228 #[serde(default = "build_connect_to")]
1229 on_complete: String,
1230 #[serde(default = "build_connect_to")]
1231 on_busy: String,
1232 #[serde(default = "build_connect_to")]
1233 on_fail: String,
1234 #[serde(default = "build_connect_to")]
1235 on_no_answer: String,
1236 #[serde(default = "build_ring_time")]
1237 ring_time: u8,
1238 #[serde(default = "build_call_time")]
1239 max_call_time: u16,
1240 #[serde(default)]
1241 transcribe_options: TranscribeOptions,
1242 #[serde(default)]
1243 record_options: RecordOptions,
1244}
1245
1246#[derive(Serialize, Deserialize, Debug)]
1247#[serde(rename_all = "camelCase")]
1248pub struct Plugin {
1249 plugin: String,
1251 data: String,
1252 #[serde(default)]
1253 record: bool,
1254 retention: String,
1255 #[serde(default = "build_present")]
1256 present: String,
1257 #[serde(default = "build_country_code")]
1258 country_code: String,
1259 #[serde(default = "build_connect_to")]
1260 on_transfer: String,
1261 #[serde(default = "build_connect_to")]
1262 on_error: String,
1263 #[serde(default = "build_connect_to")]
1264 on_complete: String,
1265 #[serde(default = "build_connect_to")]
1266 on_busy: String,
1267 #[serde(default = "build_connect_to")]
1268 on_fail: String,
1269 #[serde(default = "build_connect_to")]
1270 on_no_answer: String,
1271}
1272
1273#[derive(Serialize, Deserialize, Debug)]
1274#[serde(rename_all = "camelCase")]
1275pub struct Play {
1276 url: String,
1277 connect_to: String,
1278}
1279
1280#[derive(Serialize, Deserialize, Debug)]
1281#[serde(rename_all = "camelCase")]
1282pub struct Say {
1283 text: String,
1284 #[serde(rename = "ttsLanguage")]
1285 #[serde(default = "build_tts_voice")]
1286 tts_voice: String,
1287 #[serde(default = "build_connect_to")]
1288 connect_to: String,
1289}
1290
1291#[derive(Serialize, Deserialize, Debug)]
1292#[serde(rename_all = "camelCase")]
1293pub struct VoiceMail {
1294 text: String,
1295 #[serde(rename = "ttsLanguage")]
1296 #[serde(default = "build_tts_voice")]
1297 tts_voice: String,
1298 #[serde(default = "build_vm_finish_key")]
1299 finish_on_key: String,
1300 #[serde(default)]
1301 email_recipients: Vec<String>,
1302 #[serde(default = "build_vm_timeout")]
1303 timeout: u8,
1304 #[serde(default = "build_vm_max_length")]
1305 max_length: u8,
1306 #[serde(default)]
1307 transcribe_options: TranscribeOptions,
1308 #[serde(default)]
1309 record_options: RecordOptions,
1310 #[serde(default)]
1311 play_beep: bool,
1312 #[serde(default = "build_connect_to")]
1313 connect_to: String,
1314}
1315
1316#[derive(Serialize, Deserialize, Debug)]
1317#[serde(rename_all = "camelCase")]
1318pub struct TimeRangeRouter {
1319 #[serde(default = "build_default_timezone")]
1322 timezone: String,
1323 #[serde(default = "build_connect_to")]
1324 on_match: String,
1325 #[serde(default = "build_connect_to")]
1326 connect_to: String,
1327}
1328
1329#[derive(Serialize, Deserialize, Debug)]
1330#[serde(rename_all = "camelCase")]
1331pub struct DayOfWeekRouter {
1332 #[serde(default)]
1333 days: Vec<u8>,
1334 #[serde(default = "build_default_timezone")]
1335 timezone: String,
1336 #[serde(default = "build_connect_to")]
1337 on_match: String,
1338 #[serde(default = "build_connect_to")]
1339 connect_to: String,
1340}
1341
1342#[derive(Serialize, Deserialize, Debug)]
1343#[serde(rename_all = "camelCase")]
1344pub struct DateRangeRouter {
1345 #[serde(default = "build_connect_to")]
1346 on_match: String,
1347 #[serde(default = "build_connect_to")]
1348 connect_to: String,
1349}
1350
1351#[derive(Serialize, Deserialize, Debug)]
1352#[serde(rename_all = "camelCase")]
1353pub struct Script {
1354 code: String,
1355 #[serde(default = "build_connect_to")]
1356 connect_to: String,
1357}
1358
1359#[derive(Serialize, Deserialize, Debug)]
1360#[serde(rename_all = "camelCase")]
1361pub struct Queue {
1362 #[serde(default = "build_connect_to")]
1363 connect_to: String,
1364 }
1373
1374#[derive(Serialize, Deserialize, Debug)]
1375#[serde(rename_all = "camelCase")]
1376pub struct QueueItem {
1377 text: String,
1378 #[serde(rename = "type")]
1379 item_type: QueueItemType,
1380}
1381
1382#[derive(Serialize, Deserialize, Debug)]
1383#[serde(rename_all = "camelCase")]
1384pub struct Email {
1385 #[serde(default = "build_connect_to")]
1386 connect_to: String,
1387}
1388
1389#[derive(Serialize, Deserialize, Debug)]
1390#[serde(rename_all = "camelCase")]
1391pub struct Sms {
1392 #[serde(default = "build_connect_to")]
1393 connect_to: String,
1394}
1395
1396#[derive(Serialize, Deserialize, Debug)]
1397#[serde(rename_all = "camelCase")]
1398pub struct Tag {
1399 #[serde(default = "build_connect_to")]
1400 connect_to: String,
1401}
1402
1403#[derive(Serialize, Deserialize, Debug)]
1404#[serde(rename_all = "camelCase")]
1405pub struct TagRouter {
1406 #[serde(default = "build_connect_to")]
1407 connect_to: String,
1408}
1409
1410#[derive(Serialize, Deserialize, Debug)]
1411#[serde(rename_all = "camelCase")]
1412pub struct Service {
1413 #[serde(default = "build_connect_to")]
1414 connect_to: String,
1415}
1416
1417#[derive(Serialize, Deserialize, Debug)]
1418#[serde(rename_all = "camelCase")]
1419pub struct MessagePlugin {}
1420
1421#[derive(Serialize, Deserialize, Debug)]
1422#[serde(rename_all = "camelCase")]
1423pub struct MessageText {}
1424
1425#[derive(Serialize, Deserialize, Debug)]
1426#[serde(rename_all = "camelCase")]
1427pub struct Event {}
1428
1429#[derive(Serialize, Deserialize, Debug)]
1430#[serde(rename_all = "camelCase")]
1431pub struct MapBox {
1432 #[serde(default)]
1433 bounds: MapBoxBoundary,
1434 #[serde(default)]
1435 features: Vec<MapBoxFeature>,
1436}
1437
1438#[derive(Serialize, Deserialize, Debug)]
1439#[serde(rename_all = "camelCase")]
1440pub struct MapBoxBoundary {
1441 xmin: f32,
1442 ymin: f32,
1443 xmax: f32,
1444 ymax: f32,
1445}
1446
1447impl Default for MapBoxBoundary {
1448 fn default() -> Self {
1449 Self {
1450 xmin: 0.00,
1451 ymin: 1.00,
1452 xmax: 0.01,
1453 ymax: 1.01,
1454 }
1455 }
1456}
1457
1458#[derive(Serialize, Deserialize, Debug)]
1459#[serde(rename_all = "camelCase")]
1460pub struct MapBoxFeature {
1461 id: String,
1462 #[serde(rename = "type")]
1463 feature_type: String,
1464 geometry: MapBoxGeometry,
1465}
1466
1467#[derive(Serialize, Deserialize, Debug)]
1468#[serde(rename_all = "camelCase")]
1469pub struct MapBoxGeometry {
1470 #[serde(rename = "type")]
1471 geometry_type: String,
1472 coordinates: Vec<Vec<(f32, f32)>>,
1473}
1474
1475#[derive(Serialize, Deserialize, Debug)]
1476#[serde(rename_all = "camelCase")]
1477pub struct RouterOption {
1478 option: String,
1479 #[serde(default = "build_connect_to")]
1480 connect_to: String,
1481}
1482
1483#[derive(Serialize, Deserialize, Debug)]
1484pub struct TranscribeOptions {
1485 enabled: bool,
1486 language: String,
1487}
1488
1489impl Default for TranscribeOptions {
1490 fn default() -> Self {
1491 Self {
1492 enabled: false,
1493 language: String::from(DEFAULT_ASR_LANGUAGE),
1494 }
1495 }
1496}
1497
1498#[derive(Serialize, Deserialize, Debug)]
1499pub struct RecordOptions {
1500 #[serde(default = "build_record")]
1501 enabled: bool,
1502 #[serde(default = "build_record_retention")]
1503 retention: String,
1504}
1505
1506impl Default for RecordOptions {
1507 fn default() -> Self {
1508 Self {
1509 enabled: false,
1510 retention: String::from(DEFAULT_RECORDING_RETENTION),
1511 }
1512 }
1513}
1514
1515fn build_asr_vendor() -> String {
1516 String::from(DEFAULT_ASR_VENDOR)
1517}
1518
1519fn build_asr_language() -> String {
1520 String::from(DEFAULT_ASR_LANGUAGE)
1521}
1522
1523fn build_tts_vendor() -> String {
1524 String::from(DEFAULT_TTS_VENDOR)
1525}
1526
1527fn build_tts_language() -> String {
1528 String::from(DEFAULT_TTS_LANGUAGE)
1529}
1530
1531fn build_tts_voice() -> String {
1532 String::from(DEFAULT_TTS_VOICE)
1533}
1534
1535fn build_vm_finish_key() -> String {
1536 String::from(DEFAULT_VM_FINISH_KEY)
1537}
1538
1539fn build_default_timezone() -> String {
1540 String::from(DEFAULT_TIMEZONE)
1541}
1542
1543fn build_trunk_description() -> String {
1544 String::from(DEFAULT_TRUNK_DESCRIPTION)
1545}
1546
1547fn build_trunk_port() -> u16 {
1548 DEFAULT_TRUNK_PORT
1549}
1550
1551fn build_vm_timeout() -> u8 {
1552 DEFAULT_VM_TIMEOUT
1553}
1554
1555fn build_vm_max_length() -> u8 {
1556 DEFAULT_VM_MAX_LENGTH
1557}
1558
1559fn build_present() -> String {
1560 String::from(DEFAULT_ENDPOINT_PRESENT)
1561}
1562
1563fn build_format() -> String {
1564 String::from(DEFAULT_ENDPOINT_FORMAT)
1565}
1566
1567fn build_connect_to() -> String {
1568 String::from(HANG_UP_CONNECT)
1569}
1570
1571fn build_client_profile() -> String {
1572 String::from(DEFAULT_CLIENT_PROFILE)
1573}
1574
1575fn build_country_code() -> String {
1576 String::from(DEFAULT_COUNTRY_CODE)
1577}
1578
1579fn build_finish_key() -> String {
1580 String::from(DEFAULT_DIGITS_FINISH_KEY)
1581}
1582
1583fn build_logger() -> LoggerLevel {
1584 LoggerLevel::Warn
1585}
1586
1587fn build_call_time() -> u16 {
1588 DEFAULT_CALL_TIME
1589}
1590
1591fn build_ring_time() -> u8 {
1592 DEFAULT_RING_TIME
1593}
1594
1595fn build_digit_timeout() -> u8 {
1596 DEFAULT_DIGIT_TIMEOUT
1597}
1598
1599fn build_max_digits() -> u8 {
1600 DEFAULT_MAX_DIGITS
1601}
1602
1603fn build_record() -> bool {
1604 false
1605}
1606
1607fn build_spend_cap_value() -> u16 {
1608 100
1609}
1610
1611fn build_spend_cap_level() -> u8 {
1612 80
1613}
1614
1615fn build_spend_cap_action() -> RouteAction {
1616 RouteAction::Warn
1617}
1618
1619fn build_concurrency_action() -> RouteAction {
1620 RouteAction::Warn
1621}
1622
1623fn build_cos_action() -> COSAction {
1624 COSAction::Allow
1625}
1626
1627fn build_cos_ppm() -> f32 {
1628 15.00
1629}
1630
1631fn build_cos_ppc() -> f32 {
1632 15.00
1633}
1634
1635fn build_license() -> Licence {
1636 Licence::Standard
1637}
1638
1639fn build_record_retention() -> String {
1640 String::from(DEFAULT_RECORDING_RETENTION)
1641}
1642
1643#[test]
1644fn account_json() {
1645 let file = File::open("./assets/account-data.json").expect("file should open read only");
1646
1647 let account: Account = serde_json::from_reader(file).expect("file should be proper JSON");
1648
1649 println!("{:#?}", account);
1650
1651 for dev in &account.devices {
1652 if dev.is_connector() {
1653 if dev.connect_to().ne("HANGUP") {
1654 let device = dev.connect(&account);
1655 assert_eq!(device.is_none(), false);
1656 }
1657 }
1658 }
1659}