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
|
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
|
-
-
+
-
+
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-
+
-
+
-
-
-
+
+
+
+
+
-
+
+
+
-
-
+
+
-
-
+
+
-
-
-
-
+
+
+
+
-
-
+
-
-
+
+
+
-
+
+
+
-
+
|
use crate::core::Core;
use std::borrow::Cow;
Result
Result,
};
use frankenstein::{
methods::{
GetChatAdministratorsParams,
GetChatParams,
},
types::{
ChatId,
ChatMember,
},
AsyncTelegramApi,
ParseMode,
pub async fn start(core: &Core, chat_id: i64) -> Result<()> {
pub async fn start(core: &Core, msg: &Message) -> Result<()> {
core.send("We are open\\. Probably\\. Visit [channel](https://t.me/rsstg_bot_help/3) for details\\.",
Some(chat_id), Some(ParseMode::MarkdownV2)).await?;
Some(msg.chat.get_id()), Some(MarkdownV2)).await?;
Ok(())
}
pub async fn list(core: &mut Core, sender: i64) -> Result<()> {
let msg = core.list(sender).await?;
core.send(msg, Some(sender), Some(ParseMode::MarkdownV2)).await?;
pub async fn list(core: &Core, msg: &Message) -> Result<()> {
let sender = msg.sender.get_user_id()
.ok_or(anyhow!("Ignoring unreal users."))?;
let reply = core.list(sender).await?;
core.send(reply, Some(msg.chat.get_id()), Some(MarkdownV2)).await?;
Ok(())
}
pub async fn command(core: &mut Core, sender: i64, command: Vec<&str>) -> Result<()> {
pub async fn command (core: &Core, msg: &Message, command: &[String]) -> Result<()> {
let mut conn = core.db.begin().await?;
let sender = msg.sender.get_user_id()
.ok_or(anyhow!("Ignoring unreal users."))?;
if command.len() >= 2 {
let msg: Cow<str> = match &command[1].parse::<i32>() {
let reply = if command.len() >= 2 {
match command[1].parse::<i32>() {
Err(err) => format!("I need a number.\n{}", &err).into(),
Ok(number) => match command[0] {
"/check" => core.check(number, sender, false).await
Ok(number) => match &command[0][..] {
"/check" => core.check(number, false).await
.context("Channel check failed.")?.into(),
"/clean" => conn.clean(*number, sender).await?,
"/enable" => conn.enable(*number, sender).await?.into(),
"/delete" => conn.delete(*number, sender).await?,
"/disable" => conn.disable(*number, sender).await?.into(),
"/clean" => conn.clean(number, sender).await?,
"/enable" => conn.enable(number, sender).await?.into(),
"/delete" => conn.delete(number, sender).await?,
"/disable" => conn.disable(number, sender).await?.into(),
_ => bail!("Command {} not handled.", &command[0]),
},
};
core.send(msg, Some(sender), None).await?;
core.send("This command needs a number.", Some(sender), None).await?;
}
"This command needs a number.".into()
};
core.send(reply, Some(msg.chat.get_id()), None).await?;
Ok(())
}
pub async fn update(core: &mut Core, sender: i64, command: Vec<&str>) -> Result<()> {
pub async fn update (core: &Core, msg: &Message, command: &[String]) -> Result<()> {
let sender = msg.sender.get_user_id()
.ok_or(anyhow!("Ignoring unreal users."))?;
let mut source_id: Option<i32> = None;
let at_least = "Requires at least 3 parameters.";
let mut i_command = command.iter();
let first_word = i_command.next().context(at_least)?;
match *first_word {
match first_word.as_ref() {
"/update" => {
let next_word = i_command.next().context(at_least)?;
source_id = Some(next_word.parse::<i32>()
.context(format!("I need a number, but got {next_word}."))?);
},
"/add" => {},
_ => bail!("Passing {first_word} is not possible here."),
|
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
|
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
|
-
+
-
+
-
-
-
-
+
+
+
+
-
+
-
-
+
+
-
+
-
+
-
+
|
bail!("Usernames should be something like \"@\\[a\\-zA\\-Z]\\[a\\-zA\\-Z0\\-9\\_]+\", aren't they?\nNot {channel:?}");
};
if ! RE_LINK.is_match(url) {
bail!("Link should be a link to atom/rss feed, something like \"https://domain/path\".\nNot {url:?}");
}
let iv_hash = match iv_hash {
Some(hash) => {
match *hash {
match hash.as_ref() {
"-" => None,
thing => {
if ! RE_IV_HASH.is_match(thing) {
bail!("IV hash should be 14 hex digits.\nNot {thing:?}");
};
Some(thing)
},
}
},
None => None,
};
let url_re = match url_re {
Some(re) => {
match *re {
match re.as_ref() {
"-" => None,
thing => {
let _url_rex = ReplaceCommand::new(thing).context("Regexp parsing error:")?;
Some(thing)
}
}
},
None => None,
};
let chat_id = ChatId::String((*channel).into());
let channel_id = core.tg.get_chat(&GetChatParams { chat_id: chat_id.clone() }).await?.result.id;
let chan_adm = core.tg.get_chat_administrators(&GetChatAdministratorsParams { chat_id }).await
.context("Sorry, I have no access to that chat.")?.result;
let chat_id = ChatUsername::from(channel.clone());
let channel_id = core.tg.execute(GetChat::new(chat_id.clone())).await?.id;
let chan_adm = core.tg.execute(GetChatAdministrators::new(chat_id)).await
.context("Sorry, I have no access to that chat.")?;
let (mut me, mut user) = (false, false);
for admin in chan_adm {
let member_id = match admin {
ChatMember::Creator(member) => member.user.id,
ChatMember::Administrator(member) => member.user.id,
ChatMember::Left(_)
| ChatMember::Kicked(_)
| ChatMember::Member(_)
| ChatMember::Member{..}
| ChatMember::Restricted(_) => continue,
} as i64;
if member_id == core.me.id as i64 {
};
if member_id == core.me.id {
me = true;
};
};
core.send(conn.update(source_id, channel, channel_id, url, iv_hash, url_re, sender).await?, Some(sender), None).await?;
core.send(conn.update(source_id, channel, channel_id, url, iv_hash, url_re, sender).await?, Some(msg.chat.get_id()), None).await?;
Ok(())
}
|