989 lines
36 KiB
Rust
989 lines
36 KiB
Rust
use std::sync::Arc;
|
|
use teloxide::{
|
|
dispatching::{dialogue::{InMemStorage, Storage}, UpdateFilterExt},
|
|
net::Download,
|
|
prelude::*,
|
|
types::{
|
|
InlineKeyboardButton, InlineKeyboardMarkup, Message, ParseMode, CallbackQuery,
|
|
ChatMemberStatus, UserId,
|
|
},
|
|
utils::command::BotCommands,
|
|
};
|
|
use cgcx_config::Config;
|
|
use cgcx_core::{ContentId, ContentStatus, ReportStatus, UserRole};
|
|
use cgcx_crypto::MasterKey;
|
|
use cgcx_db::{Database, UserRepo, ContentRepo, ContentFileRepo, ReportRepo};
|
|
use cgcx_file_pipeline::FilePipeline;
|
|
use cgcx_moderation::ModerationEngine;
|
|
use cgcx_storage::Storage as CgcxStorage;
|
|
use serde::{Deserialize, Serialize};
|
|
use tracing::{info, warn};
|
|
|
|
#[derive(Clone, Default, Serialize, Deserialize)]
|
|
pub enum BotState {
|
|
#[default]
|
|
Start,
|
|
TermsPending,
|
|
MainMenu,
|
|
UploadStaging { items: Vec<StagedItem>, upload_type: UploadType },
|
|
UploadOptions { items: Vec<StagedItem>, options: UploadOptions },
|
|
UploadFinalizing,
|
|
Reporting,
|
|
ViewingPrevious { page: usize },
|
|
}
|
|
|
|
#[derive(Clone, Copy, Serialize, Deserialize)]
|
|
pub enum UploadType {
|
|
Media,
|
|
Document,
|
|
Text,
|
|
}
|
|
|
|
impl Default for UploadType {
|
|
fn default() -> Self { UploadType::Media }
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize)]
|
|
pub struct StagedItem {
|
|
pub file_id: String,
|
|
pub file_name: String,
|
|
pub mime_type: String,
|
|
pub size: u64,
|
|
pub caption: Option<String>,
|
|
}
|
|
|
|
#[derive(Clone, Default, Serialize, Deserialize)]
|
|
pub struct UploadOptions {
|
|
pub max_views: Option<u64>,
|
|
pub allow_download: bool,
|
|
pub password: Option<String>,
|
|
}
|
|
|
|
type HandlerResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;
|
|
|
|
#[derive(Clone)]
|
|
struct BotDialogue {
|
|
chat_id: ChatId,
|
|
storage: Arc<InMemStorage<BotState>>,
|
|
}
|
|
|
|
impl BotDialogue {
|
|
async fn get(&self) -> Result<BotState, Box<dyn std::error::Error + Send + Sync>> {
|
|
Ok(self.storage.clone().get_dialogue(self.chat_id).await?.unwrap_or_default())
|
|
}
|
|
async fn update(&self, state: BotState) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
Ok(self.storage.clone().update_dialogue(self.chat_id, state).await?)
|
|
}
|
|
async fn reset(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
Ok(self.storage.clone().remove_dialogue(self.chat_id).await?)
|
|
}
|
|
async fn exit(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
|
self.reset().await
|
|
}
|
|
async fn get_or_default(&self) -> Result<BotState, Box<dyn std::error::Error + Send + Sync>> {
|
|
self.get().await
|
|
}
|
|
}
|
|
|
|
#[derive(BotCommands, Clone)]
|
|
#[command(rename_rule = "lowercase", description = "Commands:")]
|
|
#[allow(dead_code)]
|
|
enum Command {
|
|
#[command(description = "Start the bot")]
|
|
Start,
|
|
}
|
|
|
|
const TERMS_TEXT: &str = r#"<b>Welcome to CG.CX</b>
|
|
|
|
Before using this service, you must read and accept the following terms:
|
|
|
|
1. <b>No Responsibility:</b> This service is not responsible for whatever media or files are shared by users.
|
|
|
|
2. <b>Content Warning:</b> Content may be uncomfortable, including bloody scenes or other disturbing material.
|
|
|
|
3. <b>Prohibited Content:</b> You must NOT upload:
|
|
• Doxes / doxxing material
|
|
• CSAM or any sexual content involving minors
|
|
• Animal cruelty material
|
|
• Malware, stealers, droppers, loaders, ransomware, weaponized files, or intentionally malicious binaries/scripts
|
|
• Suicide guides, self-harm instructions, or material explicitly intended to facilitate suicide
|
|
|
|
4. <b>Enforcement:</b> Violating these rules may result in immediate deletion, reporting to authorities, blacklisting, or moderator escalation.
|
|
|
|
<b>By clicking "Accept", you confirm you are at least 18 years old and agree to these terms.</b>"#;
|
|
|
|
#[derive(Clone)]
|
|
struct BotContext {
|
|
db: Arc<Database>,
|
|
#[allow(dead_code)]
|
|
storage: Arc<CgcxStorage>,
|
|
config: Arc<Config>,
|
|
master_key: Arc<MasterKey>,
|
|
moderation: Arc<ModerationEngine>,
|
|
pipeline: Arc<FilePipeline>,
|
|
sem: Arc<tokio::sync::Semaphore>,
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
tracing_subscriber::fmt::init();
|
|
|
|
let config = Arc::new(Config::load().expect("Failed to load config"));
|
|
|
|
let db = Arc::new(Database::open("data/db.sqlite").expect("Failed to open database"));
|
|
db.run_migrations().await.expect("Failed to run migrations");
|
|
|
|
let storage = Arc::new(CgcxStorage::new(config.storage.paths.clone()));
|
|
storage.ensure_dirs().await.expect("Failed to ensure storage dirs");
|
|
|
|
let master_key = match &config.crypto.aes_master_key_source {
|
|
cgcx_config::KeySource::Env { var } => MasterKey::load_from_env(var).expect("Failed to load master key"),
|
|
cgcx_config::KeySource::File { path } => MasterKey::load_from_file(path).expect("Failed to load master key"),
|
|
};
|
|
master_key.log_startup(false);
|
|
|
|
let moderation = Arc::new(ModerationEngine::new(&config, std::path::PathBuf::from("data")));
|
|
moderation.load().await.expect("Failed to load moderation lists");
|
|
|
|
let pipeline = Arc::new(FilePipeline::new(
|
|
(*storage).clone(),
|
|
(*db).clone(),
|
|
(*config).clone(),
|
|
));
|
|
|
|
let sem = Arc::new(tokio::sync::Semaphore::new(
|
|
(1024 * 1024 * 1024 / config.storage.chunk_size_bytes.max(1)).max(1)
|
|
));
|
|
|
|
let ctx = BotContext {
|
|
db, storage, config: config.clone(),
|
|
master_key: Arc::new(master_key), moderation, pipeline, sem,
|
|
};
|
|
|
|
let bot = Bot::new(&config.telegram.bot_token);
|
|
info!("Bot started");
|
|
|
|
let handler = dptree::entry()
|
|
.branch(Update::filter_message().endpoint(handle_message))
|
|
.branch(Update::filter_callback_query().endpoint(handle_callback));
|
|
|
|
Dispatcher::builder(bot, handler)
|
|
.dependencies(dptree::deps![InMemStorage::<BotState>::new(), ctx])
|
|
.enable_ctrlc_handler()
|
|
.build()
|
|
.dispatch()
|
|
.await;
|
|
}
|
|
|
|
async fn handle_message(
|
|
bot: Bot,
|
|
msg: Message,
|
|
storage: Arc<InMemStorage<BotState>>,
|
|
ctx: BotContext,
|
|
) -> HandlerResult {
|
|
let user = match &msg.from {
|
|
Some(u) => u.clone(),
|
|
None => return Ok(()),
|
|
};
|
|
let chat_id = msg.chat.id;
|
|
let user_id = user.id.0 as i64;
|
|
let dialogue = BotDialogue { chat_id, storage };
|
|
|
|
let user_repo = UserRepo::new(ctx.db.conn());
|
|
user_repo.ensure_exists(user_id, user.username.as_deref(), &user.first_name).await?;
|
|
|
|
let db_user = match user_repo.get(user_id).await? {
|
|
Some(u) => u,
|
|
None => return Ok(()),
|
|
};
|
|
|
|
if matches!(db_user.role, UserRole::Banned) || !ctx.moderation.is_allowed(user_id).await {
|
|
bot.send_message(chat_id, "[ Banned ] You are not allowed to use this service.").await?;
|
|
dialogue.exit().await?;
|
|
return Ok(());
|
|
}
|
|
|
|
// Admin commands in groups
|
|
if msg.chat.is_group() || msg.chat.is_supergroup() {
|
|
if let Some(text) = msg.text() {
|
|
let cmd = text.split_whitespace().next().unwrap_or("");
|
|
match cmd {
|
|
"/reload" => {
|
|
if is_admin(&bot, msg.chat.id, user.id).await {
|
|
ctx.moderation.load().await?;
|
|
bot.send_message(chat_id, "Moderation lists reloaded.").await?;
|
|
}
|
|
return Ok(());
|
|
}
|
|
"/blacklist_uid" => {
|
|
if is_admin(&bot, msg.chat.id, user.id).await {
|
|
handle_admin_blacklist_uid(&bot, chat_id, text, &ctx).await?;
|
|
}
|
|
return Ok(());
|
|
}
|
|
"/whitelist_uid" => {
|
|
if is_admin(&bot, msg.chat.id, user.id).await {
|
|
handle_admin_whitelist_uid(&bot, chat_id, text, &ctx).await?;
|
|
}
|
|
return Ok(());
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
// DM commands
|
|
if let Some(text) = msg.text() {
|
|
let cmd = text.split_whitespace().next().unwrap_or("").split('@').next().unwrap_or("");
|
|
match cmd {
|
|
"/start" => {
|
|
if db_user.accepted_terms_at.is_some() {
|
|
return send_main_menu(&bot, chat_id, &dialogue).await;
|
|
} else {
|
|
return send_terms(&bot, chat_id, &dialogue).await;
|
|
}
|
|
}
|
|
"/cancel" => {
|
|
dialogue.update(BotState::MainMenu).await?;
|
|
return send_main_menu(&bot, chat_id, &dialogue).await;
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
let state = dialogue.get_or_default().await?;
|
|
match state {
|
|
BotState::Start | BotState::TermsPending => {
|
|
if msg.text().map(|t| t == "/start").unwrap_or(false) {
|
|
send_terms(&bot, chat_id, &dialogue).await?;
|
|
}
|
|
}
|
|
BotState::UploadStaging { items, upload_type } => {
|
|
handle_staging_message(&bot, msg, &dialogue, &ctx, items, upload_type).await?;
|
|
}
|
|
BotState::UploadOptions { items, options } => {
|
|
if let Some(text) = msg.text() {
|
|
if !text.starts_with('/') && options.password.is_none() {
|
|
let mut new_options = options.clone();
|
|
new_options.password = Some(text.to_string());
|
|
let items_cloned = items.clone();
|
|
dialogue.update(BotState::UploadOptions { items: items_cloned.clone(), options: new_options.clone() }).await?;
|
|
refresh_options_message(&bot, chat_id, &items_cloned, &new_options).await?;
|
|
}
|
|
}
|
|
}
|
|
BotState::Reporting => {
|
|
if let Some(text) = msg.text() {
|
|
if !text.starts_with('/') {
|
|
handle_report(&bot, chat_id, user_id, text, &dialogue, &ctx).await?;
|
|
}
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn handle_callback(
|
|
bot: Bot,
|
|
q: CallbackQuery,
|
|
storage: Arc<InMemStorage<BotState>>,
|
|
ctx: BotContext,
|
|
) -> HandlerResult {
|
|
let data = q.data.as_deref().unwrap_or("");
|
|
let user = q.from;
|
|
let user_id = user.id.0 as i64;
|
|
|
|
if !ctx.moderation.is_allowed(user_id).await {
|
|
bot.answer_callback_query(&q.id).text("Not allowed").await?;
|
|
return Ok(());
|
|
}
|
|
|
|
let chat_id = q.message.as_ref().map(|m| m.chat().id).unwrap_or(ChatId(user_id));
|
|
let dialogue = BotDialogue { chat_id, storage };
|
|
|
|
let parts: Vec<&str> = data.split(':').collect();
|
|
if parts.len() < 3 || parts[0] != "v1" {
|
|
bot.answer_callback_query(&q.id).await?;
|
|
return Ok(());
|
|
}
|
|
|
|
match parts[1] {
|
|
"terms" => match parts[2] {
|
|
"accept" => {
|
|
let user_repo = UserRepo::new(ctx.db.conn());
|
|
user_repo.set_accepted_terms(user_id).await?;
|
|
if let Some(msg) = &q.message {
|
|
bot.delete_message(chat_id, msg.id()).await.ok();
|
|
}
|
|
send_main_menu(&bot, chat_id, &dialogue).await?;
|
|
}
|
|
"reject" => {
|
|
if let Some(msg) = &q.message {
|
|
bot.delete_message(chat_id, msg.id()).await.ok();
|
|
}
|
|
dialogue.reset().await?;
|
|
}
|
|
_ => {}
|
|
},
|
|
"menu" => match parts[2] {
|
|
"upload_media" => {
|
|
dialogue.update(BotState::UploadStaging { items: vec![], upload_type: UploadType::Media }).await?;
|
|
send_staging_message(&bot, chat_id, &[], UploadType::Media).await?;
|
|
}
|
|
"upload_doc" => {
|
|
dialogue.update(BotState::UploadStaging { items: vec![], upload_type: UploadType::Document }).await?;
|
|
send_staging_message(&bot, chat_id, &[], UploadType::Document).await?;
|
|
}
|
|
"upload_text" => {
|
|
dialogue.update(BotState::UploadStaging { items: vec![], upload_type: UploadType::Text }).await?;
|
|
send_staging_message(&bot, chat_id, &[], UploadType::Text).await?;
|
|
}
|
|
"prev_uploads" => {
|
|
dialogue.update(BotState::ViewingPrevious { page: 0 }).await?;
|
|
show_previous_uploads(&bot, chat_id, user_id, 0, &ctx).await?;
|
|
}
|
|
"report" => {
|
|
dialogue.update(BotState::Reporting).await?;
|
|
bot.send_message(chat_id, "Send me the content link or content ID to report.").await?;
|
|
}
|
|
"main" => {
|
|
send_main_menu(&bot, chat_id, &dialogue).await?;
|
|
}
|
|
_ => {}
|
|
},
|
|
"stage" => match parts[2] {
|
|
"confirm" => {
|
|
let state = dialogue.get_or_default().await?;
|
|
if let BotState::UploadStaging { items, .. } = state {
|
|
if items.is_empty() {
|
|
bot.answer_callback_query(&q.id).text("No items to upload.").await?;
|
|
} else {
|
|
let options = UploadOptions {
|
|
allow_download: true,
|
|
..Default::default()
|
|
};
|
|
dialogue.update(BotState::UploadOptions { items, options: options.clone() }).await?;
|
|
refresh_options_message(&bot, chat_id, &vec![], &options).await?;
|
|
}
|
|
}
|
|
}
|
|
"cancel" => {
|
|
if let Some(msg) = &q.message {
|
|
bot.edit_message_text(chat_id, msg.id(), "Upload cancelled.").await.ok();
|
|
}
|
|
dialogue.update(BotState::MainMenu).await?;
|
|
}
|
|
_ => {}
|
|
},
|
|
"opt" => match parts[2] {
|
|
"toggle_destroy" => {
|
|
let state = dialogue.get_or_default().await?;
|
|
if let BotState::UploadOptions { items, options } = state {
|
|
let cycle = [None, Some(1), Some(3), Some(5), Some(10), Some(50)];
|
|
let current = options.max_views;
|
|
let next = cycle.iter().skip_while(|&&x| x != current).nth(1).copied().unwrap_or(None);
|
|
let new_options = UploadOptions { max_views: next, ..options };
|
|
dialogue.update(BotState::UploadOptions { items: items.clone(), options: new_options.clone() }).await?;
|
|
refresh_options_message(&bot, chat_id, &items, &new_options).await?;
|
|
}
|
|
}
|
|
"toggle_download" => {
|
|
let state = dialogue.get_or_default().await?;
|
|
if let BotState::UploadOptions { items, options } = state {
|
|
let new_options = UploadOptions { allow_download: !options.allow_download, ..options };
|
|
dialogue.update(BotState::UploadOptions { items: items.clone(), options: new_options.clone() }).await?;
|
|
refresh_options_message(&bot, chat_id, &items, &new_options).await?;
|
|
}
|
|
}
|
|
"set_password" => {
|
|
bot.send_message(chat_id, "Send the password (max 32 chars) or /skip to skip.").await?;
|
|
}
|
|
"confirm_final" => {
|
|
let state = dialogue.get_or_default().await?;
|
|
if let BotState::UploadOptions { items, options } = state {
|
|
dialogue.update(BotState::UploadFinalizing).await?;
|
|
finalize_upload(&bot, chat_id, user_id, items, options, &dialogue, &ctx).await?;
|
|
}
|
|
}
|
|
"back" => {
|
|
dialogue.update(BotState::UploadStaging { items: vec![], upload_type: UploadType::Media }).await?;
|
|
send_staging_message(&bot, chat_id, &[], UploadType::Media).await?;
|
|
}
|
|
_ => {}
|
|
},
|
|
"prev" => {
|
|
if parts[2] == "page" {
|
|
if let Ok(page) = parts[3].parse::<usize>() {
|
|
dialogue.update(BotState::ViewingPrevious { page }).await?;
|
|
show_previous_uploads(&bot, chat_id, user_id, page, &ctx).await?;
|
|
}
|
|
}
|
|
}
|
|
"admin" => {
|
|
if parts.len() >= 4 {
|
|
handle_admin_callback(&bot, chat_id, user_id, &parts, &ctx).await?;
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
bot.answer_callback_query(&q.id).await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn send_terms(bot: &Bot, chat_id: ChatId, dialogue: &BotDialogue) -> HandlerResult {
|
|
let keyboard = InlineKeyboardMarkup::new(vec![vec![
|
|
InlineKeyboardButton::callback("[ Accept ]", "v1:terms:accept"),
|
|
InlineKeyboardButton::callback("[ Decline ]", "v1:terms:reject"),
|
|
]]);
|
|
bot.send_message(chat_id, TERMS_TEXT)
|
|
.parse_mode(ParseMode::Html)
|
|
.reply_markup(keyboard)
|
|
.await?;
|
|
dialogue.update(BotState::TermsPending).await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn send_main_menu(bot: &Bot, chat_id: ChatId, dialogue: &BotDialogue) -> HandlerResult {
|
|
let keyboard = InlineKeyboardMarkup::new(vec![
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Upload Media ]", "v1:menu:upload_media"),
|
|
InlineKeyboardButton::callback("[ Upload Docs ]", "v1:menu:upload_doc"),
|
|
],
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Upload Text ]", "v1:menu:upload_text"),
|
|
InlineKeyboardButton::callback("[ Previous Uploads ]", "v1:menu:prev_uploads"),
|
|
],
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Report Content ]", "v1:menu:report"),
|
|
],
|
|
]);
|
|
bot.send_message(chat_id, "Choose from the menu below. Administrators can be contacted here: @harmfulmeowbot")
|
|
.reply_markup(keyboard)
|
|
.await?;
|
|
dialogue.update(BotState::MainMenu).await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn send_staging_message(bot: &Bot, chat_id: ChatId, items: &[StagedItem], upload_type: UploadType) -> HandlerResult {
|
|
let type_label = match upload_type {
|
|
UploadType::Media => "Media",
|
|
UploadType::Document => "Documents",
|
|
UploadType::Text => "Text",
|
|
};
|
|
let text = if items.is_empty() {
|
|
format!("[ Staging {} (0/10) ]\n\nSend me files to add them.", type_label)
|
|
} else {
|
|
let list: String = items.iter().map(|i| format!("- {}\n", i.file_name)).collect();
|
|
format!("[ Staging {} ({}/10) ]\n\n{}", type_label, items.len(), list)
|
|
};
|
|
|
|
let keyboard = InlineKeyboardMarkup::new(vec![vec![
|
|
InlineKeyboardButton::callback("[ Confirm ]", "v1:stage:confirm"),
|
|
InlineKeyboardButton::callback("[ Cancel ]", "v1:stage:cancel"),
|
|
]]);
|
|
|
|
bot.send_message(chat_id, text)
|
|
.reply_markup(keyboard)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn handle_staging_message(
|
|
bot: &Bot,
|
|
msg: Message,
|
|
dialogue: &BotDialogue,
|
|
ctx: &BotContext,
|
|
mut items: Vec<StagedItem>,
|
|
upload_type: UploadType,
|
|
) -> HandlerResult {
|
|
if items.len() >= ctx.config.upload_limits.max_batch_size {
|
|
bot.send_message(msg.chat.id, "Maximum batch size reached.").await?;
|
|
return Ok(());
|
|
}
|
|
|
|
let mut new_item = None;
|
|
|
|
match upload_type {
|
|
UploadType::Media => {
|
|
if let Some(photo) = msg.photo() {
|
|
let largest = photo.iter().max_by_key(|p| p.file.size);
|
|
if let Some(p) = largest {
|
|
new_item = Some(StagedItem {
|
|
file_id: p.file.id.clone(),
|
|
file_name: format!("photo_{}.jpg", items.len()),
|
|
mime_type: "image/jpeg".to_string(),
|
|
size: p.file.size as u64,
|
|
caption: msg.caption().map(|s| s.to_string()),
|
|
});
|
|
}
|
|
} else if let Some(video) = msg.video() {
|
|
new_item = Some(StagedItem {
|
|
file_id: video.file.id.clone(),
|
|
file_name: video.file_name.clone().unwrap_or_else(|| format!("video_{}.mp4", items.len())),
|
|
mime_type: "video/mp4".to_string(),
|
|
size: video.file.size as u64,
|
|
caption: msg.caption().map(|s| s.to_string()),
|
|
});
|
|
} else if let Some(audio) = msg.audio() {
|
|
new_item = Some(StagedItem {
|
|
file_id: audio.file.id.clone(),
|
|
file_name: audio.file_name.clone().unwrap_or_else(|| format!("audio_{}.mp3", items.len())),
|
|
mime_type: "audio/mpeg".to_string(),
|
|
size: audio.file.size as u64,
|
|
caption: msg.caption().map(|s| s.to_string()),
|
|
});
|
|
}
|
|
}
|
|
UploadType::Document => {
|
|
if let Some(doc) = msg.document() {
|
|
new_item = Some(StagedItem {
|
|
file_id: doc.file.id.clone(),
|
|
file_name: doc.file_name.clone().unwrap_or_else(|| format!("file_{}", items.len())),
|
|
mime_type: doc.mime_type.clone().map(|m| m.to_string()).unwrap_or_else(|| "application/octet-stream".to_string()),
|
|
size: doc.file.size as u64,
|
|
caption: msg.caption().map(|s| s.to_string()),
|
|
});
|
|
}
|
|
}
|
|
UploadType::Text => {
|
|
if let Some(text) = msg.text() {
|
|
if !text.starts_with('/') {
|
|
new_item = Some(StagedItem {
|
|
file_id: format!("text://{}", msg.id.0),
|
|
file_name: "text.txt".to_string(),
|
|
mime_type: "text/plain".to_string(),
|
|
size: text.len() as u64,
|
|
caption: Some(text.to_string()),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some(item) = new_item {
|
|
items.push(item);
|
|
dialogue.update(BotState::UploadStaging { items: items.clone(), upload_type }).await?;
|
|
send_staging_message(bot, msg.chat.id, &items, upload_type).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn refresh_options_message(
|
|
bot: &Bot,
|
|
chat_id: ChatId,
|
|
_items: &[StagedItem],
|
|
options: &UploadOptions,
|
|
) -> HandlerResult {
|
|
let destroy_text = match options.max_views {
|
|
Some(n) => format!("Auto-destroy: {} views", n),
|
|
None => "Auto-destroy: Off".to_string(),
|
|
};
|
|
let download_text = if options.allow_download {
|
|
"Allow download: Yes"
|
|
} else {
|
|
"Allow download: No"
|
|
};
|
|
let password_text = if options.password.is_some() {
|
|
"Password: Set"
|
|
} else {
|
|
"Password: None"
|
|
};
|
|
|
|
let text = format!(
|
|
"[ Upload Options ]\n\n{}\n{}\n{}\n\nConfirm when ready.",
|
|
destroy_text, download_text, password_text
|
|
);
|
|
|
|
let keyboard = InlineKeyboardMarkup::new(vec![
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Toggle Destroy ]", "v1:opt:toggle_destroy"),
|
|
InlineKeyboardButton::callback("[ Toggle Download ]", "v1:opt:toggle_download"),
|
|
],
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Set Password ]", "v1:opt:set_password"),
|
|
],
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Back ]", "v1:opt:back"),
|
|
InlineKeyboardButton::callback("[ Confirm & Upload ]", "v1:opt:confirm_final"),
|
|
],
|
|
]);
|
|
|
|
bot.send_message(chat_id, text)
|
|
.reply_markup(keyboard)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn finalize_upload(
|
|
bot: &Bot,
|
|
chat_id: ChatId,
|
|
user_id: i64,
|
|
items: Vec<StagedItem>,
|
|
options: UploadOptions,
|
|
dialogue: &BotDialogue,
|
|
ctx: &BotContext,
|
|
) -> HandlerResult {
|
|
let status_msg = bot.send_message(chat_id, "[ Encrypting and storing... ]").await?;
|
|
|
|
let total_size: u64 = items.iter().map(|i| i.size).sum();
|
|
if total_size > ctx.config.upload_limits.max_total_batch_bytes {
|
|
bot.edit_message_text(chat_id, status_msg.id, "[ Error: total batch size exceeds limit. ]").await?;
|
|
dialogue.update(BotState::MainMenu).await?;
|
|
return Ok(());
|
|
}
|
|
|
|
// Check available disk space in temp dir
|
|
if let Ok(temp_path) = std::fs::canonicalize(&ctx.config.storage.paths.temp) {
|
|
if let Ok(info) = fs2::available_space(&temp_path) {
|
|
if info < total_size * 2 {
|
|
bot.edit_message_text(chat_id, status_msg.id, "[ Error: insufficient storage space. ]").await?;
|
|
dialogue.update(BotState::MainMenu).await?;
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
|
|
let content_id = ContentId::generate();
|
|
let repo = ContentRepo::new(ctx.db.conn());
|
|
let mut attempts = 0;
|
|
while repo.get(&content_id).await?.is_some() && attempts < 5 {
|
|
attempts += 1;
|
|
}
|
|
|
|
let password_hash = options.password.as_ref().map(|p| {
|
|
use argon2::{Argon2, PasswordHasher, password_hash::SaltString};
|
|
use rand::rngs::OsRng;
|
|
let salt = SaltString::generate(&mut OsRng);
|
|
let argon2 = Argon2::default();
|
|
argon2.hash_password(p.as_bytes(), &salt)
|
|
.map(|h| h.to_string())
|
|
.unwrap_or_default()
|
|
});
|
|
|
|
ctx.pipeline.create_content_entry(
|
|
content_id.clone(),
|
|
user_id,
|
|
options.max_views,
|
|
options.allow_download,
|
|
password_hash,
|
|
).await?;
|
|
|
|
for (idx, item) in items.iter().enumerate() {
|
|
let result = if item.file_id.starts_with("text://") {
|
|
let data = item.caption.clone().unwrap_or_default().into_bytes();
|
|
let mut cursor = std::io::Cursor::new(data);
|
|
ctx.pipeline.ingest_file(
|
|
&content_id,
|
|
idx as u32,
|
|
&mut cursor,
|
|
&item.file_name,
|
|
&ctx.master_key,
|
|
&ctx.sem,
|
|
).await
|
|
} else {
|
|
match bot.get_file(&item.file_id).await {
|
|
Ok(file) => {
|
|
let mut data = Vec::new();
|
|
if let Err(e) = bot.download_file(&file.path, &mut data).await {
|
|
warn!("Download error: {}", e);
|
|
continue;
|
|
}
|
|
let mut cursor = std::io::Cursor::new(data);
|
|
ctx.pipeline.ingest_file(
|
|
&content_id,
|
|
idx as u32,
|
|
&mut cursor,
|
|
&item.file_name,
|
|
&ctx.master_key,
|
|
&ctx.sem,
|
|
).await
|
|
}
|
|
Err(e) => {
|
|
warn!("Get file error: {}", e);
|
|
continue;
|
|
}
|
|
}
|
|
};
|
|
|
|
if let Err(e) = result {
|
|
warn!("Ingest error: {}", e);
|
|
}
|
|
}
|
|
|
|
ctx.pipeline.activate_content(&content_id).await?;
|
|
|
|
let base_url = &ctx.config.server.base_url;
|
|
let link = format!("{}/?cxid={}", base_url, content_id.as_str());
|
|
|
|
let mut attrs = vec![];
|
|
if let Some(v) = options.max_views {
|
|
attrs.push(format!("auto-burn after {}", v));
|
|
}
|
|
if options.allow_download {
|
|
attrs.push("download allowed".to_string());
|
|
}
|
|
if options.password.is_some() {
|
|
attrs.push("password set".to_string());
|
|
}
|
|
let attr_text = if attrs.is_empty() {
|
|
"no special options".to_string()
|
|
} else {
|
|
attrs.join(", ")
|
|
};
|
|
|
|
let result_text = format!(
|
|
"[ Upload Complete ]\n\nLink: <code>{}</code>\n\nFiles: {} | {}",
|
|
link, items.len(), attr_text
|
|
);
|
|
|
|
bot.edit_message_text(chat_id, status_msg.id, result_text)
|
|
.parse_mode(ParseMode::Html)
|
|
.await?;
|
|
|
|
dialogue.update(BotState::MainMenu).await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn show_previous_uploads(
|
|
bot: &Bot,
|
|
chat_id: ChatId,
|
|
user_id: i64,
|
|
page: usize,
|
|
ctx: &BotContext,
|
|
) -> HandlerResult {
|
|
let repo = ContentRepo::new(ctx.db.conn());
|
|
let total = repo.count_by_user(user_id).await?;
|
|
let items = repo.list_by_user(user_id, 10, page * 10).await?;
|
|
let total_pages = (total + 9) / 10;
|
|
|
|
if items.is_empty() {
|
|
bot.send_message(chat_id, "You have no uploads.").await?;
|
|
return Ok(());
|
|
}
|
|
|
|
let base_url = &ctx.config.server.base_url;
|
|
let mut text = format!("[ Your Uploads ] Page {}/{}\n\n", page + 1, total_pages.max(1));
|
|
for content in &items {
|
|
let file_repo = ContentFileRepo::new(ctx.db.conn());
|
|
let files = file_repo.list_by_content(&content.id).await?;
|
|
let mut attrs = vec![];
|
|
if let Some(v) = content.max_views {
|
|
attrs.push(format!("auto-burn after {}", v));
|
|
}
|
|
if content.allow_download {
|
|
attrs.push("download allowed".to_string());
|
|
}
|
|
if content.password_hash.is_some() {
|
|
attrs.push("password set".to_string());
|
|
}
|
|
let attr_text = if attrs.is_empty() { "no options".to_string() } else { attrs.join(", ") };
|
|
|
|
text.push_str(&format!(
|
|
"- <code>{}</code> ({} files) [{}]\n {}?cxid={}\n\n",
|
|
content.id.as_str(), files.len(), attr_text, base_url, content.id.as_str()
|
|
));
|
|
}
|
|
|
|
let mut buttons = vec![];
|
|
if page > 0 {
|
|
buttons.push(InlineKeyboardButton::callback("<<", format!("v1:prev:page:{}", page - 1)));
|
|
}
|
|
buttons.push(InlineKeyboardButton::callback(format!("Page {}/{}", page + 1, total_pages.max(1)), "noop"));
|
|
if page + 1 < total_pages {
|
|
buttons.push(InlineKeyboardButton::callback(">>", format!("v1:prev:page:{}", page + 1)));
|
|
}
|
|
|
|
let keyboard = InlineKeyboardMarkup::new(vec![buttons, vec![
|
|
InlineKeyboardButton::callback("[ Main Menu ]", "v1:menu:main"),
|
|
]]);
|
|
|
|
bot.send_message(chat_id, text)
|
|
.parse_mode(ParseMode::Html)
|
|
.reply_markup(keyboard)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn handle_report(
|
|
bot: &Bot,
|
|
chat_id: ChatId,
|
|
reporter_id: i64,
|
|
text: &str,
|
|
dialogue: &BotDialogue,
|
|
ctx: &BotContext,
|
|
) -> HandlerResult {
|
|
let cxid = extract_cxid(text).ok_or("Invalid content ID or link")?;
|
|
let content_id = ContentId::try_from(cxid.as_str())?;
|
|
|
|
let repo = ContentRepo::new(ctx.db.conn());
|
|
let content = repo.get(&content_id).await?.ok_or("Content not found")?;
|
|
|
|
let report_repo = ReportRepo::new(ctx.db.conn());
|
|
let report_id = report_repo.insert(&content_id, reporter_id, text).await?;
|
|
|
|
for &group_id in &ctx.config.groups.review_group_ids {
|
|
let report_text = format!(
|
|
"[ NEW REPORT ] #{}\n\nCXID: <code>{}</code>\nReporter: <code>{}</code>\nOwner: <code>{}</code>\nUploaded: {}\nFiles: {}",
|
|
report_id,
|
|
cxid,
|
|
reporter_id,
|
|
content.user_id,
|
|
content.created_at.format("%Y-%m-%d %H:%M"),
|
|
1
|
|
);
|
|
|
|
let keyboard = InlineKeyboardMarkup::new(vec![
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Delete + Blacklist ]", format!("v1:admin:delblk:{}", report_id)),
|
|
InlineKeyboardButton::callback("[ Delete Only ]", format!("v1:admin:del:{}", report_id)),
|
|
],
|
|
vec![
|
|
InlineKeyboardButton::callback("[ Blacklist Only ]", format!("v1:admin:blk:{}", report_id)),
|
|
InlineKeyboardButton::callback("[ Ignore ]", format!("v1:admin:ign:{}", report_id)),
|
|
],
|
|
]);
|
|
|
|
bot.send_message(ChatId(group_id), report_text)
|
|
.parse_mode(ParseMode::Html)
|
|
.reply_markup(keyboard)
|
|
.await
|
|
.ok();
|
|
}
|
|
|
|
bot.send_message(chat_id, "Report submitted. Moderators will review it shortly.").await?;
|
|
dialogue.update(BotState::MainMenu).await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn handle_admin_callback(
|
|
bot: &Bot,
|
|
chat_id: ChatId,
|
|
user_id: i64,
|
|
parts: &[&str],
|
|
ctx: &BotContext,
|
|
) -> HandlerResult {
|
|
if !is_admin_in_chat(bot, chat_id, UserId(user_id as u64)).await {
|
|
bot.send_message(chat_id, "Unauthorized.").await?;
|
|
return Ok(());
|
|
}
|
|
|
|
let report_id = parts[3].parse::<i64>().unwrap_or(0);
|
|
let report_repo = ReportRepo::new(ctx.db.conn());
|
|
let report = match report_repo.get(report_id).await? {
|
|
Some(r) => r,
|
|
None => {
|
|
bot.send_message(chat_id, "Report not found.").await?;
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
let content_repo = ContentRepo::new(ctx.db.conn());
|
|
let content = match content_repo.get(&report.content_id).await? {
|
|
Some(c) => c,
|
|
None => {
|
|
bot.send_message(chat_id, "Content not found.").await?;
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
match parts[2] {
|
|
"delblk" => {
|
|
ctx.pipeline.delete_content(&report.content_id, !ctx.config.content.keep_content).await.ok();
|
|
content_repo.set_status(&report.content_id, ContentStatus::Deleted).await.ok();
|
|
ctx.moderation.blacklist(content.user_id).await.ok();
|
|
let user_repo = UserRepo::new(ctx.db.conn());
|
|
user_repo.set_role(content.user_id, "banned").await.ok();
|
|
report_repo.resolve(report_id, ReportStatus::Actioned, user_id).await.ok();
|
|
bot.send_message(chat_id, format!("Deleted content {} and blacklisted user {}", report.content_id.as_str(), content.user_id))
|
|
.parse_mode(ParseMode::Html).await?;
|
|
}
|
|
"del" => {
|
|
ctx.pipeline.delete_content(&report.content_id, !ctx.config.content.keep_content).await.ok();
|
|
content_repo.set_status(&report.content_id, ContentStatus::Deleted).await.ok();
|
|
report_repo.resolve(report_id, ReportStatus::Actioned, user_id).await.ok();
|
|
bot.send_message(chat_id, format!("Deleted content {}", report.content_id.as_str()))
|
|
.parse_mode(ParseMode::Html).await?;
|
|
}
|
|
"blk" => {
|
|
ctx.moderation.blacklist(content.user_id).await.ok();
|
|
let user_repo = UserRepo::new(ctx.db.conn());
|
|
user_repo.set_role(content.user_id, "banned").await.ok();
|
|
report_repo.resolve(report_id, ReportStatus::Actioned, user_id).await.ok();
|
|
bot.send_message(chat_id, format!("Blacklisted user {}", content.user_id))
|
|
.parse_mode(ParseMode::Html).await?;
|
|
}
|
|
"ign" => {
|
|
report_repo.resolve(report_id, ReportStatus::Dismissed, user_id).await.ok();
|
|
bot.send_message(chat_id, format!("Ignored report #{}", report_id))
|
|
.parse_mode(ParseMode::Html).await?;
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn extract_cxid(input: &str) -> Option<String> {
|
|
let re = regex::Regex::new(r"[?&]cxid=([a-zA-Z0-9]{12})").ok()?;
|
|
if let Some(cap) = re.captures(input) {
|
|
return cap.get(1).map(|m| m.as_str().to_string());
|
|
}
|
|
let trimmed = input.trim();
|
|
if trimmed.len() == 12 && trimmed.chars().all(|c| c.is_ascii_alphanumeric()) {
|
|
return Some(trimmed.to_string());
|
|
}
|
|
None
|
|
}
|
|
|
|
async fn is_admin(bot: &Bot, chat_id: ChatId, user_id: UserId) -> bool {
|
|
match bot.get_chat_member(chat_id, user_id).await {
|
|
Ok(member) => {
|
|
matches!(member.status(), ChatMemberStatus::Administrator | ChatMemberStatus::Owner)
|
|
}
|
|
Err(_) => false,
|
|
}
|
|
}
|
|
|
|
async fn is_admin_in_chat(bot: &Bot, chat_id: ChatId, user_id: UserId) -> bool {
|
|
is_admin(bot, chat_id, user_id).await
|
|
}
|
|
|
|
async fn handle_admin_blacklist_uid(
|
|
bot: &Bot,
|
|
chat_id: ChatId,
|
|
text: &str,
|
|
ctx: &BotContext,
|
|
) -> HandlerResult {
|
|
let uid = text.split_whitespace().nth(1).and_then(|s| s.parse::<i64>().ok());
|
|
if let Some(uid) = uid {
|
|
ctx.moderation.blacklist(uid).await?;
|
|
let user_repo = UserRepo::new(ctx.db.conn());
|
|
user_repo.set_role(uid, "banned").await?;
|
|
bot.send_message(chat_id, format!("Blacklisted UID <code>{}</code>", uid))
|
|
.parse_mode(ParseMode::Html).await?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn handle_admin_whitelist_uid(
|
|
bot: &Bot,
|
|
chat_id: ChatId,
|
|
text: &str,
|
|
ctx: &BotContext,
|
|
) -> HandlerResult {
|
|
let uid = text.split_whitespace().nth(1).and_then(|s| s.parse::<i64>().ok());
|
|
if let Some(uid) = uid {
|
|
ctx.moderation.remove_blacklist(uid).await?;
|
|
let user_repo = UserRepo::new(ctx.db.conn());
|
|
user_repo.set_role(uid, "user").await?;
|
|
bot.send_message(chat_id, format!("Whitelisted UID <code>{}</code>", uid))
|
|
.parse_mode(ParseMode::Html).await?;
|
|
}
|
|
Ok(())
|
|
}
|