dojo/scootaloo
1
0
Fork 0
mirror of https://framagit.org/veretcle/scootaloo.git synced 2025-07-20 17:11:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

style: fmt & clippy processed

Browse Source
This commit is contained in:
VC
2022-08-11 12:29:40 +02:00
parent dab8725f99
commit b11595bfca
10 changed files with 297 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
src/lib.rs
View File

@@ -2,12 +2,12 @@ mod error;
use error::ScootalooError;
mod config;
use config::Config;
pub use config::parse_toml;
use config::Config;
mod mastodon;
use mastodon::{get_mastodon_token, build_basic_status};
pub use mastodon::register;
use mastodon::{build_basic_status, get_mastodon_token};
mod twitter;
use twitter::*;
@@ -15,31 +15,28 @@ use twitter::*;
mod util;
mod state;
use state::{read_state, write_state, TweetToToot};
pub use state::init_db;
use state::{read_state, write_state, TweetToToot};
use elefren::{prelude::*, status_builder::StatusBuilder};
use log::{debug, error, info, warn};
use rusqlite::Connection;
use std::borrow::Cow;
use tokio::fs::remove_file;
use elefren::{
prelude::*,
status_builder::StatusBuilder,
};
use log::{info, warn, error, debug};
use rusqlite::Connection;
/// This is where the magic happens
#[tokio::main]
pub async fn run(config: Config) {
// open the SQLite connection
let conn = Connection::open(&config.scootaloo.db_path)
.unwrap_or_else(|e|
panic!("Something went wrong when opening the DB {}: {}", &config.scootaloo.db_path, e)
);
let conn = Connection::open(&config.scootaloo.db_path).unwrap_or_else(|e| {
panic!(
"Something went wrong when opening the DB {}: {}",
&config.scootaloo.db_path, e
)
});
// retrieve the last tweet ID for the username
let last_tweet_id = read_state(&conn, None)
.unwrap_or_else(|e|
panic!("Cannot retrieve last_tweet_id: {}", e)
)
.unwrap_or_else(|e| panic!("Cannot retrieve last_tweet_id: {}", e))
.map(|s| s.tweet_id);
// get OAuth2 token
@@ -51,9 +48,12 @@ pub async fn run(config: Config) {
// get user timeline feed (Vec<tweet>)
let mut feed = get_user_timeline(&config.twitter, token, last_tweet_id)
.await
.unwrap_or_else(|e|
panic!("Something went wrong when trying to retrieve {}’s timeline: {}", &config.twitter.username, e)
);
.unwrap_or_else(|e| {
panic!(
"Something went wrong when trying to retrieve {}’s timeline: {}",
&config.twitter.username, e
)
});
// empty feed -> exiting
if feed.is_empty() {
@@ -69,34 +69,37 @@ pub async fn run(config: Config) {
// initiate the toot_reply_id var
let mut toot_reply_id: Option<String> = None;
// determine if the tweet is part of a thread (response to self) or a standard response
if let Some(r) = &tweet.in_reply_to_screen_name {
if &r.to_lowercase() != &config.twitter.username.to_lowercase() {
// we are responding not threading
info!("Tweet is a direct response, skipping");
continue;
}
info!("Tweet is a thread");
toot_reply_id = read_state(&conn, tweet.in_reply_to_status_id)
.unwrap_or(None)
.map(|s| s.toot_id);
if let Some(r) = &tweet.in_reply_to_screen_name {
if r.to_lowercase() != config.twitter.username.to_lowercase() {
// we are responding not threading
info!("Tweet is a direct response, skipping");
continue;
}
info!("Tweet is a thread");
toot_reply_id = read_state(&conn, tweet.in_reply_to_status_id)
.unwrap_or(None)
.map(|s| s.toot_id);
};
// build basic status by just yielding text and dereferencing contained urls
let mut status_text = build_basic_status(tweet);
let mut status_medias: Vec<String> = vec![];
// reupload the attachments if any
// reupload the attachments if any
if let Some(m) = &tweet.extended_entities {
for media in &m.media {
let local_tweet_media_path = match get_tweet_media(&media, &config.scootaloo.cache_path).await {
Ok(m) => m,
Err(e) => {
error!("Cannot get tweet media for {}: {}", &media.url, e);
continue;
},
};
let local_tweet_media_path =
match get_tweet_media(media, &config.scootaloo.cache_path).await {
Ok(m) => m,
Err(e) => {
error!("Cannot get tweet media for {}: {}", &media.url, e);
continue;
}
};
let mastodon_media_ids = match mastodon.media(Cow::from(local_tweet_media_path.to_owned())) {
let mastodon_media_ids = match mastodon
.media(Cow::from(local_tweet_media_path.to_owned()))
{
Ok(m) => {
remove_file(&local_tweet_media_path)
.await
@@ -104,9 +107,12 @@ pub async fn run(config: Config) {
warn!("Attachment for {} has been uploaded, but I’m unable to remove the existing file: {}", &local_tweet_media_path, e)
);
m.id
},
}
Err(e) => {
error!("Attachment {} cannot be uploaded to Mastodon Instance: {}", &local_tweet_media_path, e);
error!(
"Attachment {} cannot be uploaded to Mastodon Instance: {}",
&local_tweet_media_path, e
);
continue;
}
};
@@ -123,15 +129,15 @@ pub async fn run(config: Config) {
let mut status_builder = StatusBuilder::new();
status_builder.status(&status_text)
.media_ids(status_medias);
status_builder.status(&status_text).media_ids(status_medias);
if let Some(i) = toot_reply_id {
status_builder.in_reply_to(&i);
}
let status = status_builder.build()
.expect(&format!("Cannot build status with text {}", &status_text));
let status = status_builder
.build()
.unwrap_or_else(|_| panic!("Cannot build status with text {}", &status_text));
// publish status
// again unwrap is safe here as we are in the main thread
@@ -145,9 +151,7 @@ pub async fn run(config: Config) {
};
// write the current state (tweet ID and toot ID) to avoid copying it another time
write_state(&conn, ttt_towrite).unwrap_or_else(|e|
panic!("Can’t write the last tweet retrieved: {}", e)
);
write_state(&conn, ttt_towrite)
.unwrap_or_else(|e| panic!("Can’t write the last tweet retrieved: {}", e));
}
}