forked from moorage/mtproto
-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathmanager_message.go
433 lines (415 loc) · 10.4 KB
/
manager_message.go
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
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
package mtproto
import (
"fmt"
"log"
"math/rand"
"reflect"
)
type Message struct {
Flags MessageFlags
Type string
ID int32
From int32
To *Peer
Date int32
Body string
MediaType string
Action *MessageAction
ForwardHeader *MessageForwardHeader
Entities []MessageEntity
Views int32
Media interface{}
}
type MessageFlags struct {
Out bool // flags_1?true
Mentioned bool // flags_4?true
MediaUnread bool // flags_5?true
Silent bool // flags_13?true
Post bool // flags_14?true
}
func (f *MessageFlags) loadFlags(flags int32) {
if flags&1<<1 != 0 {
f.Out = true
}
if flags&1<<4 != 0 {
f.Mentioned = true
}
if flags&1<<5 != 0 {
f.MediaUnread = true
}
if flags&1<<13 != 0 {
f.Silent = true
}
if flags&1<<14 != 0 {
f.Post = true
}
}
type MessageAction struct {
Type string
Title string
ChatID int32
ChannelID int32
GameID int64
GameScore int32
UserID int32
UserIDs []int32
Photo *Photo
}
type MessageEntity struct {
Type string
Offset int32
Length int32
Url string
Language string
UserID int32
}
type MessageForwardHeader struct {
From int32
Date int32
ChannelID int32
ChannelPost int32
Author string
}
type MessageMedia interface{}
type MessageMediaPhoto struct {
Caption string
Photo Photo
}
type MessageMediaContact struct {
Firstname string
Lastname string
UserID int32
Phone string
}
type MessageMediaDocument struct {
Caption string
Document Document
}
type MessageReplyMarkup struct {
}
// NewMessage
// input
// 1. TL_message
// 2. TL_messageService
func NewMessage(input TL) (m *Message) {
m = new(Message)
switch x := input.(type) {
case TL_messageEmpty:
return nil
case TL_message:
m.Flags.loadFlags(x.Flags)
m.Type = MESSAGE_TYPE_NORMAL
m.ID = x.Id
m.Date = x.Date
m.From = x.From_id
m.Body = x.Message
m.To = NewPeer(x.To_id)
m.Views = x.Views
if x.Media != nil {
m.Media = NewMessageMedia(x.Media)
}
if x.Fwd_from != nil {
m.ForwardHeader = NewMessageForwardHeader(x.Fwd_from)
}
m.Entities = make([]MessageEntity, 0, 0)
for _, e := range x.Entities {
m.Entities = append(m.Entities, *NewMessageEntity(e))
}
case TL_messageService:
m.Flags.loadFlags(x.Flags)
m.Type = MESSAGE_TYPE_SERVICE
m.ID = x.Id
m.Date = x.Date
m.From = x.From_id
m.To = NewPeer(x.To_id)
m.Action = NewMessageAction(x.Action)
m.ForwardHeader = new(MessageForwardHeader)
default:
fmt.Println("NewMessage::UnSupported Input Format", reflect.TypeOf(x).String())
return nil
}
return
}
// NewMessageAction
// input:
// 1. TL_messageActionEmpty
// 2. TL_messageActionChannelCreate
// 3. TL_messageActionChannelMigrateFrom
// 4. TL_messageActionChatCreate
// 5. TL_messageActionChatAddUser
// 6. TL_messageActionChatDeleteUser
// 7. TL_messageActionChatDeleteUser
// 8. TL_messageActionChatEditPhoto
// 9. TL_messageActionChatEditTitle
// 10. TL_messageActionChatJoinedByLink
// 11. TL_messageActionChatMigrateTo
// 12. TL_messageActionGameScore
// 13. TL_messageActionHistoryClear
// 14. TL_messageActionPinMessage
// 15. TL_messageActionPhoneCall
func NewMessageAction(input TL) (m *MessageAction) {
m = new(MessageAction)
switch x := input.(type) {
case TL_messageActionEmpty:
case TL_messageActionChannelCreate:
m.Type = MESSAGE_ACTION_CHANNEL_CREATED
m.Title = x.Title
case TL_messageActionChannelMigrateFrom:
m.Type = MESSAGE_ACTION_CHANNEL_MIGRATE_FROM
m.Title = x.Title
m.ChatID = x.Chat_id
case TL_messageActionChatCreate:
m.Type = MESSAGE_ACTION_CHAT_CREATED
m.Title = x.Title
m.UserIDs = x.Users
case TL_messageActionChatAddUser:
m.Type = MESSAGE_ACTION_CHAT_ADD_USER
m.UserIDs = x.Users
case TL_messageActionChatDeleteUser:
m.Type = MESSAGE_ACTION_CHAT_DELETE_USER
m.UserID = x.User_id
case TL_messageActionChatDeletePhoto:
m.Type = MESSAGE_ACTION_CHAT_DELETE_PHOTO
case TL_messageActionChatEditPhoto:
m.Type = MESSAGE_ACTION_CHAT_EDIT_PHOTO
m.Photo = NewPhoto(x.Photo)
case TL_messageActionChatEditTitle:
m.Type = MESSAGE_ACTION_CHAT_EDIT_TITLE
m.Title = x.Title
case TL_messageActionChatJoinedByLink:
m.Type = MESSAGE_ACTION_CHAT_JOINED_BY_LINK
m.UserID = x.Inviter_id
case TL_messageActionChatMigrateTo:
m.Type = MESSAGE_ACTION_CHAT_MIGRATE_TO
m.ChannelID = x.Channel_id
case TL_messageActionGameScore:
m.Type = MESSAGE_ACTION_GAME_SCORE
m.GameID = x.Game_id
m.GameScore = x.Score
case TL_messageActionHistoryClear:
m.Type = MESSAGE_ACTION_HISTORY_CLEAN
case TL_messageActionPinMessage:
case TL_messageActionPhoneCall:
m.Type = MESSAGE_ACTION_PHONE_CALL
default:
fmt.Println("NewMessageAction::UnSupported Input Format", reflect.TypeOf(x).String())
}
return
}
func NewMessageEntity(input TL) (e *MessageEntity) {
e = new(MessageEntity)
switch x := input.(type) {
case TL_messageEntityBold:
e.Type = MESSAGE_ENTITY_BOLD
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityEmail:
e.Type = MESSAGE_ENTITY_EMAIL
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityBotCommand:
e.Type = MESSAGE_ENTITY_BOT_COMMAND
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityHashtag:
e.Type = MESSAGE_ENTITY_HASHTAG
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityCode:
e.Type = MESSAGE_ENTITY_CODE
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityItalic:
e.Type = MESSAGE_ENTITY_ITALIC
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityMention:
e.Type = MESSAGE_ENTITY_MENTION
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityUrl:
e.Type = MESSAGE_ENTITY_URL
e.Offset, e.Length = x.Offset, x.Length
case TL_messageEntityTextUrl:
e.Type = MESSAGE_ENTITY_TEXT_URL
e.Offset, e.Length = x.Offset, x.Length
e.Url = x.Url
case TL_messageEntityPre:
e.Type = MESSAGE_ENTITY_PRE
e.Offset, e.Length = x.Offset, x.Length
e.Language = x.Language
case TL_messageEntityMentionName:
e.Type = MESSAGE_ENTITY_MENTION_NAME
e.Offset, e.Length = x.Offset, x.Length
e.UserID = x.User_id
default:
fmt.Println("NewMessageEntity::UnSupported Input Format", reflect.TypeOf(x).String())
}
return e
}
func NewMessageForwardHeader(input TL) (fwd *MessageForwardHeader) {
fwd = new(MessageForwardHeader)
fwdHeader := input.(TL_messageFwdHeader)
fwd.Date = fwdHeader.Date
fwd.From = fwdHeader.From_id
fwd.ChannelID = fwdHeader.Channel_id
fwd.ChannelPost = fwdHeader.Channel_post
fwd.Author = fwdHeader.Post_author
return
}
// NewMessageMedia
// input:
// 1. TL_messageMediaPhoto
// 2. TL_messageMediaContact
// 3. TL_messageMediaDocument
//
func NewMessageMedia(input TL) interface{} {
switch x := input.(type) {
case TL_messageMediaPhoto:
mm := new(MessageMediaPhoto)
mm.Caption = x.Caption
mm.Photo = *NewPhoto(x.Photo)
return mm
case TL_messageMediaContact:
mm := new(MessageMediaContact)
mm.UserID = x.User_id
mm.Firstname = x.First_name
mm.Lastname = x.Last_name
mm.Phone = x.Phone_number
return mm
case TL_messageMediaDocument:
mm := new(MessageMediaDocument)
mm.Caption = x.Caption
mm.Document = *NewDocument(x.Document)
return mm
case TL_messageMediaWebPage:
// TODO:: implement it
default:
fmt.Println("NewMessageMedia::UnSupported Input Format", reflect.TypeOf(x).String())
}
return nil
}
func (m *MTProto) Messages_SendMessage(text string, peer TL, reply_to int32) (interface{}, error) {
resp := make(chan TL, 1)
m.queueSend <- packetToSend{
TL_messages_sendMessage{
0,
peer,
reply_to,
text,
rand.Int63(),
TL_null{},
nil,
},
resp,
}
x := <-resp
switch r := x.(type) {
default:
log.Println(reflect.TypeOf(r))
return r, nil
}
}
func (m *MTProto) Messages_ImportChatInvite(hash string) *Chat {
resp := make(chan TL, 1)
m.queueSend <- packetToSend{
TL_messages_importChatInvite{
hash,
},
resp,
}
x := <-resp
switch r := x.(type) {
case TL_updates:
chat := NewChat(r.Chats[0])
return chat
case TL_rpc_error:
log.Println(r.error_code, r.error_message)
default:
log.Println(reflect.TypeOf(r))
}
return nil
}
func (m *MTProto) Messages_GetHistory(inputPeer TL, offs_id, offs_date, add_offs, limit, min_id, max_id int32) ([]Message, int32, error) {
resp := make(chan TL, 1)
m.queueSend <- packetToSend{
TL_messages_getHistory{
Offset_id: offs_id,
Offset_date: offs_date,
Add_offset: add_offs,
Peer: inputPeer,
Limit: limit,
Max_id: max_id,
Min_id: min_id,
},
resp,
}
x := <-resp
messages := make([]Message, 0, 20)
switch input := x.(type) {
case TL_messages_messages:
for _, m := range input.Messages {
msg := NewMessage(m)
if msg != nil {
messages = append(messages, *msg)
}
}
return messages, int32(len(messages)), nil
case TL_messages_messagesSlice:
for _, m := range input.Messages {
msg := NewMessage(m)
if msg != nil {
messages = append(messages, *msg)
}
}
return messages, input.Count, nil
case TL_messages_channelMessages:
for _, m := range input.Messages {
msg := NewMessage(m)
if msg != nil {
messages = append(messages, *msg)
}
}
return messages, input.Count, nil
case TL_rpc_error:
// fmt.Println(input.error_message, input.error_code)
return messages, 0, fmt.Errorf("[%d] %s", input.error_code, input.error_message)
default:
// fmt.Println(reflect.TypeOf(input).String())
return messages, 0, fmt.Errorf("hist: unknown answer: %s", reflect.TypeOf(input).String())
}
}
func (m *MTProto) Messages_GetChats(chatIDs []int32) ([]Chat, error) {
resp := make(chan TL, 1)
m.queueSend <- packetToSend{
TL_messages_getChats{
Id: chatIDs,
},
resp,
}
x := <-resp
chats := make([]Chat, 0, len(chatIDs))
switch input := x.(type) {
case TL_messages_chats:
for _, ch := range input.Chats {
chats = append(chats, *NewChat(ch))
}
return chats, nil
case TL_rpc_error:
fmt.Println(input.error_code, input.error_message)
return chats, fmt.Errorf("TL_rpc_error: %d - %s", input.error_code, input.error_message)
default:
fmt.Println(reflect.TypeOf(input).String())
return chats, fmt.Errorf("Don't know how to handle response: %s - %v", reflect.TypeOf(input).String(), input)
}
}
func (m *MTProto) Messages_GetFullChat(chatID int32) *Chat {
resp := make(chan TL, 1)
m.queueSend <- packetToSend{
TL_messages_getFullChat{
Chat_id: chatID,
},
resp,
}
x := <-resp
chat := new(Chat)
switch input := x.(type) {
case TL_messages_chatFull:
chat = NewChat(input)
default:
}
return chat
}