205 lines
7.3 KiB
Rust
205 lines
7.3 KiB
Rust
use chrono::{Duration, Utc};
|
|
use clap::Parser;
|
|
use uuid::Uuid;
|
|
|
|
use mitra::activitypub::builders::delete_note::prepare_delete_note;
|
|
use mitra::activitypub::builders::delete_person::prepare_delete_person;
|
|
use mitra::activitypub::fetcher::fetchers::fetch_actor;
|
|
use mitra::activitypub::handlers::update_person::update_actor;
|
|
use mitra::config;
|
|
use mitra::database::create_database_client;
|
|
use mitra::database::migrate::apply_migrations;
|
|
use mitra::ethereum::signatures::generate_ecdsa_key;
|
|
use mitra::ethereum::utils::key_to_ethereum_address;
|
|
use mitra::logger::configure_logger;
|
|
use mitra::models::attachments::queries::delete_unused_attachments;
|
|
use mitra::models::posts::queries::{delete_post, find_extraneous_posts, get_post_by_id};
|
|
use mitra::models::profiles::queries::{delete_profile, get_profile_by_id};
|
|
use mitra::models::users::queries::{
|
|
create_invite_code,
|
|
get_invite_codes,
|
|
get_user_by_id,
|
|
};
|
|
use mitra::utils::crypto::{generate_private_key, serialize_private_key};
|
|
|
|
/// Admin CLI tool
|
|
#[derive(Parser)]
|
|
struct Opts {
|
|
#[clap(subcommand)]
|
|
subcmd: SubCommand,
|
|
}
|
|
|
|
#[derive(Parser)]
|
|
enum SubCommand {
|
|
GenerateRsaKey(GenerateRsaKey),
|
|
GenerateEthereumAddress(GenerateEthereumAddress),
|
|
|
|
GenerateInviteCode(GenerateInviteCode),
|
|
ListInviteCodes(ListInviteCodes),
|
|
RefetchActor(RefetchActor),
|
|
DeleteProfile(DeleteProfile),
|
|
DeletePost(DeletePost),
|
|
DeleteExtraneousPosts(DeleteExtraneousPosts),
|
|
DeleteUnusedAttachments(DeleteUnusedAttachments),
|
|
}
|
|
|
|
/// Generate RSA private key
|
|
#[derive(Parser)]
|
|
struct GenerateRsaKey;
|
|
|
|
impl GenerateRsaKey {
|
|
fn execute(&self) -> () {
|
|
let private_key = generate_private_key().unwrap();
|
|
let private_key_str = serialize_private_key(&private_key).unwrap();
|
|
println!("{}", private_key_str);
|
|
}
|
|
}
|
|
|
|
/// Generate ethereum address
|
|
#[derive(Parser)]
|
|
struct GenerateEthereumAddress;
|
|
|
|
/// Generate invite code
|
|
#[derive(Parser)]
|
|
struct GenerateInviteCode;
|
|
|
|
/// List invite codes
|
|
#[derive(Parser)]
|
|
struct ListInviteCodes;
|
|
|
|
/// Re-fetch actor profile by actor ID
|
|
#[derive(Parser)]
|
|
struct RefetchActor {
|
|
#[clap(short)]
|
|
id: String,
|
|
}
|
|
|
|
/// Delete profile
|
|
#[derive(Parser)]
|
|
struct DeleteProfile {
|
|
#[clap(short)]
|
|
id: Uuid,
|
|
}
|
|
|
|
/// Delete post
|
|
#[derive(Parser)]
|
|
struct DeletePost {
|
|
#[clap(short)]
|
|
id: Uuid,
|
|
}
|
|
|
|
/// Delete old remote posts
|
|
#[derive(Parser)]
|
|
struct DeleteExtraneousPosts {
|
|
#[clap(short)]
|
|
days: i64,
|
|
|
|
#[clap(long)]
|
|
dry_run: bool,
|
|
}
|
|
|
|
/// Delete attachments that doesn't belong to any post
|
|
#[derive(Parser)]
|
|
struct DeleteUnusedAttachments {
|
|
#[clap(short)]
|
|
days: i64,
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
let opts: Opts = Opts::parse();
|
|
|
|
match opts.subcmd {
|
|
SubCommand::GenerateRsaKey(cmd) => cmd.execute(),
|
|
SubCommand::GenerateEthereumAddress(_) => {
|
|
let private_key = generate_ecdsa_key();
|
|
let address = key_to_ethereum_address(&private_key);
|
|
println!(
|
|
"address {:?}; private key {}",
|
|
address, private_key.display_secret(),
|
|
);
|
|
},
|
|
subcmd => {
|
|
// Other commands require initialized app
|
|
let config = config::parse_config();
|
|
configure_logger(config.log_level);
|
|
log::info!("config loaded from {}", config.config_path);
|
|
let db_config = config.database_url.parse().unwrap();
|
|
let db_client = &mut create_database_client(&db_config).await;
|
|
apply_migrations(db_client).await;
|
|
|
|
match subcmd {
|
|
SubCommand::GenerateInviteCode(_) => {
|
|
let invite_code = create_invite_code(db_client).await.unwrap();
|
|
println!("generated invite code: {}", invite_code);
|
|
},
|
|
SubCommand::ListInviteCodes(_) => {
|
|
let invite_codes = get_invite_codes(db_client).await.unwrap();
|
|
if invite_codes.is_empty() {
|
|
println!("no invite codes found");
|
|
return;
|
|
};
|
|
for code in invite_codes {
|
|
println!("{}", code);
|
|
};
|
|
},
|
|
SubCommand::RefetchActor(subopts) => {
|
|
let actor_id = subopts.id;
|
|
let actor = fetch_actor(&config.instance(), &actor_id).await.unwrap();
|
|
update_actor(db_client, &config.media_dir(), actor).await.unwrap();
|
|
println!("profile updated");
|
|
},
|
|
SubCommand::DeleteProfile(subopts) => {
|
|
let profile = get_profile_by_id(db_client, &subopts.id).await.unwrap();
|
|
let mut maybe_delete_person = None;
|
|
if profile.is_local() {
|
|
let user = get_user_by_id(db_client, &profile.id).await.unwrap();
|
|
let activity = prepare_delete_person(db_client, config.instance(), &user)
|
|
.await.unwrap();
|
|
maybe_delete_person = Some(activity);
|
|
};
|
|
let deletion_queue = delete_profile(db_client, &profile.id).await.unwrap();
|
|
deletion_queue.process(&config).await;
|
|
// Send Delete(Person) activities
|
|
if let Some(activity) = maybe_delete_person {
|
|
activity.deliver().await.unwrap();
|
|
};
|
|
println!("profile deleted");
|
|
},
|
|
SubCommand::DeletePost(subopts) => {
|
|
let post = get_post_by_id(db_client, &subopts.id).await.unwrap();
|
|
let deletion_queue = delete_post(db_client, &post.id).await.unwrap();
|
|
deletion_queue.process(&config).await;
|
|
if post.author.is_local() {
|
|
// Send Delete(Note) activity
|
|
let author = get_user_by_id(db_client, &post.author.id).await.unwrap();
|
|
prepare_delete_note(db_client, config.instance(), &author, &post).await.unwrap()
|
|
.deliver().await.unwrap();
|
|
};
|
|
println!("post deleted");
|
|
},
|
|
SubCommand::DeleteExtraneousPosts(subopts) => {
|
|
let created_before = Utc::now() - Duration::days(subopts.days);
|
|
let posts = find_extraneous_posts(db_client, &created_before).await.unwrap();
|
|
for post_id in posts {
|
|
if !subopts.dry_run {
|
|
let deletion_queue = delete_post(db_client, &post_id).await.unwrap();
|
|
deletion_queue.process(&config).await;
|
|
};
|
|
println!("post {} deleted", post_id);
|
|
};
|
|
},
|
|
SubCommand::DeleteUnusedAttachments(subopts) => {
|
|
let created_before = Utc::now() - Duration::days(subopts.days);
|
|
let deletion_queue = delete_unused_attachments(
|
|
db_client,
|
|
&created_before,
|
|
).await.unwrap();
|
|
deletion_queue.process(&config).await;
|
|
println!("unused attachments deleted");
|
|
},
|
|
_ => panic!(),
|
|
};
|
|
},
|
|
};
|
|
}
|