forked from mymmrac/telego
/
predicates.go
520 lines (440 loc) · 16.2 KB
/
predicates.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
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
package handlers
import (
"regexp"
"strings"
"github.com/dsurl/tgo"
)
// Union is true if at least one of the predicates is true
func Union(predicates ...Predicate) Predicate {
return func(update tgo.Update) bool {
for _, p := range predicates {
if p(update) {
return true
}
}
return false
}
}
// Not is true if predicate is false
func Not(predicate Predicate) Predicate {
return func(update tgo.Update) bool {
return !predicate(update)
}
}
func anyMassage(message *tgo.Message) bool {
return message != nil
}
// AnyMessage is true if the message isn't nil
func AnyMessage() Predicate {
return func(update tgo.Update) bool {
return anyMassage(update.Message)
}
}
func anyMassageWithText(message *tgo.Message) bool {
return message != nil && message.Text != ""
}
// AnyMessageWithText is true if the message isn't nil and its text is not empty
func AnyMessageWithText() Predicate {
return func(update tgo.Update) bool {
return anyMassageWithText(update.Message)
}
}
func textEqual(message *tgo.Message, text string) bool {
return message != nil && message.Text == text
}
// TextEqual is true if the message isn't nil, and its text is equal to the specified text
func TextEqual(text string) Predicate {
return func(update tgo.Update) bool {
return textEqual(update.Message, text)
}
}
func textEqualFold(message *tgo.Message, text string) bool {
return message != nil && strings.EqualFold(message.Text, text)
}
// TextEqualFold is true if the message isn't nil, and its text equal fold (more general form of case-insensitivity
// equal) to the specified text
func TextEqualFold(text string) Predicate {
return func(update tgo.Update) bool {
return textEqualFold(update.Message, text)
}
}
func textContains(message *tgo.Message, text string) bool {
return message != nil && strings.Contains(message.Text, text)
}
// TextContains is true if the message isn't nil, and its text contains specified text
func TextContains(text string) Predicate {
return func(update tgo.Update) bool {
return textContains(update.Message, text)
}
}
func textPrefix(message *tgo.Message, prefix string) bool {
return message != nil && strings.HasPrefix(message.Text, prefix)
}
// TextPrefix is true if the message isn't nil, and its text has specified prefix
func TextPrefix(prefix string) Predicate {
return func(update tgo.Update) bool {
return textPrefix(update.Message, prefix)
}
}
func textSuffix(message *tgo.Message, suffix string) bool {
return message != nil && strings.HasSuffix(message.Text, suffix)
}
// TextSuffix is true if the message isn't nil, and its text has specified suffix
func TextSuffix(suffix string) Predicate {
return func(update tgo.Update) bool {
return textSuffix(update.Message, suffix)
}
}
func textMatches(message *tgo.Message, pattern *regexp.Regexp) bool {
return message != nil && pattern.MatchString(message.Text)
}
// TextMatches is true if the message isn't nil, and its text matches specified regexp
func TextMatches(pattern *regexp.Regexp) Predicate {
return func(update tgo.Update) bool {
return textMatches(update.Message, pattern)
}
}
// CommandRegexp matches to command and has match groups on command and arguments
var CommandRegexp = regexp.MustCompile(`^/(\w+) ?(.*)$`)
// CommandMatchGroupsLen represents the length of match groups in the CommandRegexp
const CommandMatchGroupsLen = 3
// AnyCommand is true if the message isn't nil, and it matches to command regexp
func AnyCommand() Predicate {
return func(update tgo.Update) bool {
return update.Message != nil && CommandRegexp.MatchString(update.Message.Text)
}
}
// CommandEqual is true if the message isn't nil, and it contains specified command
func CommandEqual(command string) Predicate {
return func(update tgo.Update) bool {
if update.Message == nil {
return false
}
matches := CommandRegexp.FindStringSubmatch(update.Message.Text)
if len(matches) != CommandMatchGroupsLen {
return false
}
return strings.EqualFold(matches[1], command)
}
}
// CommandEqualArgc is true if the message isn't nil, and it contains specified command with a number of args
func CommandEqualArgc(command string, argc int) Predicate {
return func(update tgo.Update) bool {
if update.Message == nil {
return false
}
matches := CommandRegexp.FindStringSubmatch(update.Message.Text)
if len(matches) != CommandMatchGroupsLen {
return false
}
return strings.EqualFold(matches[1], command) &&
(argc == 0 && matches[2] == "" || len(strings.Split(matches[2], " ")) == argc)
}
}
// CommandEqualArgv is true if the message isn't nil, and it contains specified command and args
func CommandEqualArgv(command string, argv ...string) Predicate {
return func(update tgo.Update) bool {
if update.Message == nil {
return false
}
matches := CommandRegexp.FindStringSubmatch(update.Message.Text)
if len(matches) != CommandMatchGroupsLen {
return false
}
return strings.EqualFold(matches[1], command) &&
(len(argv) == 0 && matches[2] == "" || matches[2] == strings.Join(argv, " "))
}
}
// SuccessPayment is true if the message isn't nil, and contains success payment
func SuccessPayment() Predicate {
return func(update tgo.Update) bool {
return update.Message != nil && update.Message.SuccessfulPayment != nil
}
}
// AnyEditedMessage is true if the edited message isn't nil
func AnyEditedMessage() Predicate {
return func(update tgo.Update) bool {
return anyMassage(update.EditedMessage)
}
}
// AnyEditedMessageWithText is true if the edited message isn't nil and its text is not empty
func AnyEditedMessageWithText() Predicate {
return func(update tgo.Update) bool {
return anyMassageWithText(update.EditedMessage)
}
}
// EditedTextEqual is true if the edited message isn't nil, and its text equals to the specified text
func EditedTextEqual(text string) Predicate {
return func(update tgo.Update) bool {
return textEqual(update.EditedMessage, text)
}
}
// EditedTextEqualFold is true if the edited message isn't nil, and its text equal fold (more general form of
// case-insensitivity equal) to the specified text
func EditedTextEqualFold(text string) Predicate {
return func(update tgo.Update) bool {
return textEqualFold(update.EditedMessage, text)
}
}
// EditedTextContains is true if the edited message isn't nil, and its text contains specified text
func EditedTextContains(text string) Predicate {
return func(update tgo.Update) bool {
return textContains(update.EditedMessage, text)
}
}
// EditedTextPrefix is true if the edited message isn't nil, and its text has specified prefix
func EditedTextPrefix(prefix string) Predicate {
return func(update tgo.Update) bool {
return textPrefix(update.EditedMessage, prefix)
}
}
// EditedTextSuffix is true if the edited message isn't nil, and its text has specified suffix
func EditedTextSuffix(suffix string) Predicate {
return func(update tgo.Update) bool {
return textSuffix(update.EditedMessage, suffix)
}
}
// EditedTextMatches is true if the edited message isn't nil, and its text matches specified regexp
func EditedTextMatches(pattern *regexp.Regexp) Predicate {
return func(update tgo.Update) bool {
return textMatches(update.EditedMessage, pattern)
}
}
// AnyChannelPost is true if channel post isn't nil
func AnyChannelPost() Predicate {
return func(update tgo.Update) bool {
return anyMassage(update.ChannelPost)
}
}
// AnyChannelPostWithText is true if channel post isn't nil and its text is not empty
func AnyChannelPostWithText() Predicate {
return func(update tgo.Update) bool {
return anyMassageWithText(update.ChannelPost)
}
}
// PostTextEqual is true if channel post isn't nil, and its text equals to the specified text
func PostTextEqual(text string) Predicate {
return func(update tgo.Update) bool {
return textEqual(update.ChannelPost, text)
}
}
// PostTextEqualFold is true if channel post isn't nil, and its text equal fold (more general form of case-insensitivity
// equal) to the specified text
func PostTextEqualFold(text string) Predicate {
return func(update tgo.Update) bool {
return textEqualFold(update.ChannelPost, text)
}
}
// PostTextContains is true if channel post isn't nil, and its text contains specified text
func PostTextContains(text string) Predicate {
return func(update tgo.Update) bool {
return textContains(update.ChannelPost, text)
}
}
// PostTextPrefix is true if channel post isn't nil, and its text has specified prefix
func PostTextPrefix(prefix string) Predicate {
return func(update tgo.Update) bool {
return textPrefix(update.ChannelPost, prefix)
}
}
// PostTextSuffix is true if channel post isn't nil, and its text has specified suffix
func PostTextSuffix(suffix string) Predicate {
return func(update tgo.Update) bool {
return textSuffix(update.ChannelPost, suffix)
}
}
// PostTextMatches is true if channel post isn't nil, and its text matches specified regexp
func PostTextMatches(pattern *regexp.Regexp) Predicate {
return func(update tgo.Update) bool {
return textMatches(update.ChannelPost, pattern)
}
}
// AnyEditedChannelPost is true if the edited channel post isn't nil
func AnyEditedChannelPost() Predicate {
return func(update tgo.Update) bool {
return anyMassage(update.EditedChannelPost)
}
}
// AnyEditedChannelPostWithText is true if edited channel post isn't nil and its text is not empty
func AnyEditedChannelPostWithText() Predicate {
return func(update tgo.Update) bool {
return anyMassageWithText(update.EditedChannelPost)
}
}
// EditedPostTextEqual is true if edited channel post isn't nil, and its text equals to the specified text
func EditedPostTextEqual(text string) Predicate {
return func(update tgo.Update) bool {
return textEqual(update.EditedChannelPost, text)
}
}
// EditedPostTextEqualFold is true if edited channel post isn't nil, and its text equal fold (more general form of
// case-insensitivity equal) to the specified text
func EditedPostTextEqualFold(text string) Predicate {
return func(update tgo.Update) bool {
return textEqualFold(update.EditedChannelPost, text)
}
}
// EditedPostTextContains is true if edited channel post isn't nil, and its text contains specified text
func EditedPostTextContains(text string) Predicate {
return func(update tgo.Update) bool {
return textContains(update.EditedChannelPost, text)
}
}
// EditedPostTextPrefix is true if edited channel post isn't nil, and its text has specified prefix
func EditedPostTextPrefix(prefix string) Predicate {
return func(update tgo.Update) bool {
return textPrefix(update.EditedChannelPost, prefix)
}
}
// EditedPostTextSuffix is true if edited channel post isn't nil, and its text has specified suffix
func EditedPostTextSuffix(suffix string) Predicate {
return func(update tgo.Update) bool {
return textSuffix(update.EditedChannelPost, suffix)
}
}
// EditedPostTextMatches is true if edited channel post isn't nil, and its text matches specified regexp
func EditedPostTextMatches(pattern *regexp.Regexp) Predicate {
return func(update tgo.Update) bool {
return textMatches(update.EditedChannelPost, pattern)
}
}
// AnyInlineQuery is true if inline query isn't nil
func AnyInlineQuery() Predicate {
return func(update tgo.Update) bool {
return update.InlineQuery != nil
}
}
// InlineQueryEqual is true if inline query isn't nil, and its query equal to specified text
func InlineQueryEqual(text string) Predicate {
return func(update tgo.Update) bool {
return update.InlineQuery != nil && update.InlineQuery.Query == text
}
}
// InlineQueryEqualFold is true if inline query isn't nil, and its query equal fold (more general form of
// case-insensitivity equal) to the specified text
func InlineQueryEqualFold(text string) Predicate {
return func(update tgo.Update) bool {
return update.InlineQuery != nil && strings.EqualFold(update.InlineQuery.Query, text)
}
}
// InlineQueryContains is true if inline query isn't nil, and its query contains specified text
func InlineQueryContains(text string) Predicate {
return func(update tgo.Update) bool {
return update.InlineQuery != nil && strings.Contains(update.InlineQuery.Query, text)
}
}
// InlineQueryPrefix is true if inline query isn't nil, and its query has specified prefix
func InlineQueryPrefix(prefix string) Predicate {
return func(update tgo.Update) bool {
return update.InlineQuery != nil && strings.HasPrefix(update.InlineQuery.Query, prefix)
}
}
// InlineQuerySuffix is true if inline query isn't nil, and its query has specified suffix
func InlineQuerySuffix(suffix string) Predicate {
return func(update tgo.Update) bool {
return update.InlineQuery != nil && strings.HasSuffix(update.InlineQuery.Query, suffix)
}
}
// InlineQueryMatches is true if inline query isn't nil, and its query matches specified regexp
func InlineQueryMatches(pattern *regexp.Regexp) Predicate {
return func(update tgo.Update) bool {
return update.InlineQuery != nil && pattern.MatchString(update.InlineQuery.Query)
}
}
// AnyChosenInlineResult is true if the chosen inline result isn't nil
func AnyChosenInlineResult() Predicate {
return func(update tgo.Update) bool {
return update.ChosenInlineResult != nil
}
}
// AnyCallbackQuery is true if the callback query isn't nil
func AnyCallbackQuery() Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil
}
}
// AnyCallbackQueryWithMessage is true if callback query and its message isn't nil
func AnyCallbackQueryWithMessage() Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil && update.CallbackQuery.Message != nil
}
}
// CallbackDataEqual is true if callback query isn't nil, and its data equal to specified text
func CallbackDataEqual(text string) Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil && update.CallbackQuery.Data == text
}
}
// CallbackDataEqualFold is true if the callback query isn't nil, and its data equal fold (more general form of
// case-insensitivity equal) to the specified text
func CallbackDataEqualFold(text string) Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil && strings.EqualFold(update.CallbackQuery.Data, text)
}
}
// CallbackDataContains is true if the callback query isn't nil, and its data contains specified text
func CallbackDataContains(text string) Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil && strings.Contains(update.CallbackQuery.Data, text)
}
}
// CallbackDataPrefix is true if the callback query isn't nil, and its data has specified prefix
func CallbackDataPrefix(prefix string) Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil && strings.HasPrefix(update.CallbackQuery.Data, prefix)
}
}
// CallbackDataSuffix is true if the callback query isn't nil, and its data has specified suffix
func CallbackDataSuffix(suffix string) Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil && strings.HasSuffix(update.CallbackQuery.Data, suffix)
}
}
// CallbackDataMatches is true if the callback query isn't nil, and its data matches specified regexp
func CallbackDataMatches(pattern *regexp.Regexp) Predicate {
return func(update tgo.Update) bool {
return update.CallbackQuery != nil && pattern.MatchString(update.CallbackQuery.Data)
}
}
// AnyShippingQuery is true if shipping query isn't nil
func AnyShippingQuery() Predicate {
return func(update tgo.Update) bool {
return update.ShippingQuery != nil
}
}
// AnyPreCheckoutQuery is true if the pre checkout query isn't nil
func AnyPreCheckoutQuery() Predicate {
return func(update tgo.Update) bool {
return update.PreCheckoutQuery != nil
}
}
// AnyPoll is true if the poll isn't nil
func AnyPoll() Predicate {
return func(update tgo.Update) bool {
return update.Poll != nil
}
}
// AnyPollAnswer is true if the poll answer isn't nil
func AnyPollAnswer() Predicate {
return func(update tgo.Update) bool {
return update.PollAnswer != nil
}
}
// AnyMyChatMember is true if my chat member isn't nil
func AnyMyChatMember() Predicate {
return func(update tgo.Update) bool {
return update.MyChatMember != nil
}
}
// AnyChatMember is true if chat member isn't nil
func AnyChatMember() Predicate {
return func(update tgo.Update) bool {
return update.ChatMember != nil
}
}
// AnyChatJoinRequest is true if chat join request isn't nil
func AnyChatJoinRequest() Predicate {
return func(update tgo.Update) bool {
return update.ChatJoinRequest != nil
}
}