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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
use crate::types::*;
use crate::vision::possibility::PossibilityMessage;

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct Message {
  /// Unique message identifier inside this chat.
  pub id: i64,
  /// Sender, can be empty for messages sent to channels.
  pub from: Option<User>,
  /// Date the message was sent in Unix time.
  pub date: i64,
  //  /// Conversation the message belongs to.
//  pub chat: Chat,
  /// Information about the original message.
  pub forward: Option<Forward>,
  /// For replies, the original message. Note that the Message object in this field will not
  /// contain further reply_to_message fields even if it itself is a reply.
  pub reply_to_message: Option<PossibilityMessage>,
  /// Date the message was last edited in Unix time.
  pub edit_date: Option<i64>,
  /// Message kind, Message | Channel
  pub chat: VMessageChat,
  /// Message is edited
  pub is_edited: bool,
}

impl Message {
  pub fn is_channel(&self) -> bool {
    match self.chat {
      VMessageChat::Channel(_) => true,
      _ => false
    }
  }

  pub fn is_group(&self) -> bool {
    match self.chat {
      VMessageChat::Message(MessageChat::Group(_)) => true,
      _ => false
    }
  }

  pub fn is_private(&self) -> bool {
    match self.chat {
      VMessageChat::Message(MessageChat::Private(_)) => true,
      _ => false
    }
  }

  pub fn is_supergroup(&self) -> bool {
    match self.chat {
      VMessageChat::Message(MessageChat::Supergroup(_)) => true,
      _ => false
    }
  }
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub enum VMessageChat {
  Message(MessageChat),
  Channel(Channel),
}

impl VMessageChat {
  pub fn id(&self) -> i64 {
    match *self {
      VMessageChat::Message(ref x) => x.id(),
      VMessageChat::Channel(ref x) => x.id
    }
  }
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VTextMessage {
  pub message: Message,
  pub text: String,
  pub entities: Vec<MessageEntity>,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VAudioMessage {
  pub message: Message,
  pub audio: Audio,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VDocumentMessage {
  pub message: Message,
  pub document: Document,
  pub caption: Option<String>,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VPhotoMessage {
  pub message: Message,
  pub photo: Vec<PhotoSize>,
  pub caption: Option<String>,
  pub media_group_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VStickerMessage {
  pub message: Message,
  pub sticker: Sticker,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VVideoMessage {
  pub message: Message,
  pub video: Video,
  pub caption: Option<String>,
  pub media_group_id: Option<String>,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VVoiceMessage {
  pub message: Message,
  pub voice: Voice,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VVideoNoteMessage {
  pub message: Message,
  pub video_note: VideoNote,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VContactMessage {
  pub message: Message,
  pub contact: Contact,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VLocationMessage {
  pub message: Message,
  pub location: Location,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VVenueMessage {
  pub message: Message,
  pub venue: Venue,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VNewChatMembersMessage {
  pub message: Message,
  pub members: Vec<User>,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VLeftChatMemberMessage {
  pub message: Message,
  pub member: User,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VChatTitleMessage {
  pub message: Message,
  pub title: String,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VChatPhotoMessage {
  pub message: Message,
  pub photos: Vec<PhotoSize>,
}

//pub struct VDeleteChatPhotoMessage {
//  pub message: Message,
//}
//
//pub struct VGroupChatCreatedMessage {
//  pub message: Message,
//}
//
//pub struct VSupergroupChatCreatedMessage {
//  pub message: Message,
//}
//
//pub struct VChannelChatCreatedMessage {
//  pub message: Message,
//}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VMigrateToChatIdMessage {
  pub message: Message,
  pub migrate_to_chat_id: i64,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VMigrateFromChatIdMessage {
  pub message: Message,
  pub migrate_from_chat_id: i64,
}

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct VPinnedMessageMessage {
  pub message: Message,
  pub pinned: Box<RawMessage>,
}