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

use serde_derive::{Deserialize, Serialize};
use serde_json::Value;

mod audio;
mod flex;
mod image;
mod image_map;
mod location;
mod sticker;
mod template;
mod text;
mod video;

pub use audio::*;
pub use flex::*;
pub use image::*;
pub use image_map::*;
pub use location::*;
pub use sticker::*;
pub use template::*;
pub use text::*;
pub use video::*;

pub trait LineMessageObject {
    fn build(&self) -> Value;
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LineMessagesBuilder {
    pub messages: Vec<Value>,
    pub notification_disabled: Option<bool>,
    pub custom_aggregation_units: Option<Vec<String>>,
}

impl LineMessagesBuilder {
    pub fn new() -> Self {
        Self {
            messages: vec![],
            notification_disabled: None,
            custom_aggregation_units: None,
        }
    }
    pub fn set_notification_disabled(&mut self, notification_disabled: bool) {
        self.notification_disabled = Some(notification_disabled);
    }
    pub fn set_custom_aggregation_units(&mut self, custom_aggregation_units: Vec<String>) {
        self.custom_aggregation_units = Some(custom_aggregation_units);
    }
    pub fn append(&mut self, message: impl LineMessageObject) {
        self.messages.push(message.build())
    }

    pub fn to_reply_request(&self, reply_token: String) -> LineApiMessageReplyRequest {
        LineApiMessageReplyRequest {
            reply_token,
            messages: self.messages.clone(),
            notification_disabled: self.notification_disabled,
        }
    }
    pub fn to_push_request<T: ToString>(&self, to: T) -> LineApiMessagePushRequest {
        LineApiMessagePushRequest {
            to: to.to_string(),
            messages: self.messages.clone(),
            notification_disabled: self.notification_disabled,
            custom_aggregation_units: self.custom_aggregation_units.clone(),
        }
    }
    pub fn to_multi_cast_request(&self, to: Vec<String>) -> LineApiMessageMulticastRequest {
        LineApiMessageMulticastRequest {
            to,
            messages: self.messages.clone(),
            notification_disabled: self.notification_disabled,
            custom_aggregation_units: self.custom_aggregation_units.clone(),
        }
    }
    pub fn to_broad_cast_request(&self) -> LineApiMessageBroadcastRequest {
        LineApiMessageBroadcastRequest {
            messages: self.messages.clone(),
            notification_disabled: self.notification_disabled,
        }
    }
    pub fn to_actions(&self) -> Vec<Value> {
        self.messages.clone()
    }
}

#[derive(Debug, Default, Deserialize, Serialize, Clone)]
pub struct LineApiMessageReplyRequest {
    #[serde(rename = "notificationDisabled")]
    pub reply_token: String,
    #[serde(flatten)]
    pub messages: Vec<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "notificationDisabled")]
    pub notification_disabled: Option<bool>,
}

#[derive(Debug, Default, Deserialize, Serialize, Clone)]
pub struct LineApiMessagePushRequest {
    pub to: String,
    pub messages: Vec<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "notificationDisabled")]
    pub notification_disabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "customAggregationUnits")]
    pub custom_aggregation_units: Option<Vec<String>>,
}

#[derive(Debug, Default, Deserialize, Serialize, Clone)]
pub struct LineApiMessageMulticastRequest {
    pub to: Vec<String>,
    pub messages: Vec<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "notificationDisabled")]
    pub notification_disabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "customAggregationUnits")]
    pub custom_aggregation_units: Option<Vec<String>>,
}

#[derive(Debug, Default, Deserialize, Serialize, Clone)]
pub struct LineApiMessageBroadcastRequest {
    pub messages: Vec<Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "notificationDisabled")]
    pub notification_disabled: Option<bool>,
}