blankie
/
rss-anime-notifier-rs
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: blankie:cli
Branches Tags
blankie:cli
blankie:master
..
compare: blankie:master
Branches Tags
blankie:cli
blankie:master

No commits in common. "cli" and "master" have entirely different histories.
cli ... master

5 changed files with 1038 additions and 402 deletions
Show Stats Expand all files Collapse all files

1196
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

13
Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "rss-anime-notifier-rs"
version = "0.2.4"
version = "0.1.4"
authors = ["blank X <theblankx@protonmail.com>"]
edition = "2018"
@ -10,9 +10,10 @@ edition = "2018"
lto = true
[dependencies]
quick-xml = "0.22"
chrono = "0.4"
rss = "1.9.0"
warp = "0.2.5"
chrono = "0.4.19"
serde_json = "1.0"
reqwest = "0.11"
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1.18", features = ["rt"] }
reqwest = "0.10.8"
serde = { version = "1.0.117", features = ["derive"] }
tokio = { version = "0.2.22", features = ["rt-core"] }

2
LICENSE
View File

@ -1,6 +1,6 @@
MIT License
Copyright (c) 2021 blank X
Copyright (c) 2020 blank X
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal

13
README.md
View File

@ -1,11 +1,16 @@
# RSS Anime Notifier but in Rust
Get anime schedule from https://anichart.net and gives an RSS feed to episodes that have already aired to standard output
Get anime schedule from https://anichart.net and gives an RSS feed to episodes that have already aired
### How to Build and Run
https://doc.rust-lang.org/stable/book/ch01-03-hello-cargo.html#building-and-running-a-cargo-project
### Environment Variables
`PORT` - Specify the port to listen to, default: 8080
### How to Use
`rss-anime-notifier-rs <anime id>`
For example, if the URL is https://anilist.co/anime/112609/Majo-no-Tabitabi, the anime ID is 112609
To use with newsboat, check out https://brokenco.de/2020/07/07/newsboat-wacky-feeds.html
1. Start the script, obviously
2. Get the Anilist anime ID
For example, if the URL is https://anilist.co/anime/112609/Majo-no-Tabitabi, the anime ID is 112609
3. Add http://127.0.0.1:[port]/[animeID] to your RSS reader
For example, if your port is 8080 and the anime ID is 112609, you'd use http://127.0.0.1:8080/112609

216
src/main.rs
View File

@ -1,18 +1,18 @@
extern crate rss;
extern crate warp;
extern crate serde;
extern crate tokio;
extern crate chrono;
extern crate reqwest;
extern crate serde_json;
use std::env;
use std::path::Path;
use std::io::Cursor;
use std::process::exit;
use std::convert::Infallible;
use reqwest::Client;
use serde_json::json;
use quick_xml::Writer;
use serde::Deserialize;
use warp::{Filter, http::response};
use chrono::{Utc, DateTime, NaiveDateTime};
use quick_xml::events::{Event, BytesStart, BytesText, BytesEnd};
use rss::{Item, ItemBuilder, ChannelBuilder, GuidBuilder};
const QUERY: &str = r#"query ($id: Int) {
Media (id: $id) {
@ -49,7 +49,7 @@ struct Data {
struct Media {
pub title: MediaTitle,
pub airing_schedule: AiringScheduleConnection,
pub episodes: Option<i32>,
pub episodes: Option<isize>,
pub site_url: String
}
@ -67,48 +67,43 @@ struct AiringScheduleConnection {
#[derive(Deserialize)]
#[serde(rename_all="camelCase")]
struct AiringSchedule {
pub id: i32,
pub id: isize,
pub airing_at: i64,
pub time_until_airing: i64,
pub episode: i32
pub episode: isize
}
async fn get_data(anime_id: i32) -> Root {
let client = Client::new();
async fn give_response(anime_id: usize, client: Client) -> Result<impl warp::Reply, Infallible> {
let json = json!({"query": QUERY, "variables": {"id": anime_id}});
serde_json::from_str(&client.post("https://graphql.anilist.co/")
let resp = match client.post("https://graphql.anilist.co/")
.header("Content-Type", "application/json")
.header("Accept", "application/json")
.body(json.to_string())
.send()
.await
.unwrap()
.text()
.await
.unwrap()).unwrap()
}
fn main() {
let mut args = env::args();
let path = args.next().expect("Cannot get binary path");
let path = Path::new(&path).file_stem().unwrap().to_str().unwrap();
let anime_id = match args.next() {
Some(anime_id) => anime_id.parse::<i32>().unwrap(),
None => {
eprintln!("Usage: {} <anime id>", path);
exit(1);
}
};
let resp = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap()
.block_on(get_data(anime_id));
.await {
Ok(resp) => match resp.text().await {
Ok(resp) => match serde_json::from_str::<Root>(&resp) {
Ok(resp) => resp,
Err(err) => {
eprintln!("ERROR: {}", err);
return Ok(response::Builder::new().status(502).header("Content-Type", "type/plain").body(format!("502\n{}", err)));
}
},
Err(err) => {
eprintln!("ERROR: {}", err);
return Ok(response::Builder::new().status(502).header("Content-Type", "type/plain").body(format!("502\n{}", err)));
}
},
Err(err) => {
eprintln!("ERROR: {}", err);
return Ok(response::Builder::new().status(503).header("Content-Type", "type/plain").body(format!("503\n{}", err)));
}
};
let mut pub_date = Utc::now().to_rfc2822();
let mut last_build_date = pub_date.clone();
let resp = &resp.data.media;
let title = resp.title.english.as_ref().unwrap_or(&resp.title.romaji);
let mut items: Vec<(i32, String, String)> = Vec::with_capacity(resp.airing_schedule.nodes.len());
let mut items: Vec<Item> = Vec::with_capacity(resp.airing_schedule.nodes.len());
for i in &resp.airing_schedule.nodes {
let i_date = DateTime::<Utc>::from_utc(NaiveDateTime::from_timestamp(i.airing_at, 0), Utc).to_rfc2822();
pub_date = i_date.clone();
@ -120,114 +115,49 @@ fn main() {
if Some(i.episode) == resp.episodes {
title.push_str(" END");
}
items.push((i.id, i_date, title));
items.push(ItemBuilder::default()
.title(title)
.link(resp.site_url.clone())
.pub_date(i_date)
.guid(GuidBuilder::default().permalink(false).value(format!("ran-{}-{}", anime_id, i.id)).build().unwrap())
.build()
.unwrap()
);
}
items.reverse();
let mut writer = Writer::new(Cursor::new(Vec::new()));
{
let mut elem = BytesStart::owned(b"rss".to_vec(), 3);
elem.push_attribute(("version", "2.0"));
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesStart::owned(b"channel".to_vec(), 7);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesStart::owned(b"title".to_vec(), 5);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&title).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"title".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesStart::owned(b"link".to_vec(), 4);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&resp.site_url).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"link".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesStart::owned(b"description".to_vec(), 11);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&format!("Aired episodes of {}", &title)).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"description".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesStart::owned(b"pubDate".to_vec(), 7);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&pub_date).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"pubDate".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesStart::owned(b"lastBuildDate".to_vec(), 13);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&last_build_date).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"lastBuildDate".to_vec());
writer.write_event(Event::End(elem)).unwrap();
}
for (id, date, title) in items {
let elem = BytesStart::owned(b"item".to_vec(), 4);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesStart::owned(b"title".to_vec(), 5);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&title).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"title".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesStart::owned(b"link".to_vec(), 4);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&resp.site_url).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"link".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesStart::owned(b"guid".to_vec(), 4);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&format!("ran-{}-{}", &anime_id, id)).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"guid".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesStart::owned(b"pubDate".to_vec(), 7);
writer.write_event(Event::Start(elem)).unwrap();
let elem = BytesText::from_plain_str(&date).into_owned();
writer.write_event(Event::Text(elem)).unwrap();
let elem = BytesEnd::owned(b"pubDate".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesEnd::owned(b"item".to_vec());
writer.write_event(Event::End(elem)).unwrap();
}
let elem = BytesEnd::owned(b"channel".to_vec());
writer.write_event(Event::End(elem)).unwrap();
let elem = BytesEnd::owned(b"rss".to_vec());
writer.write_event(Event::End(elem)).unwrap();
println!("{}", String::from_utf8(writer.into_inner().into_inner()).unwrap());
let channel = ChannelBuilder::default()
.title(title)
.link(resp.site_url.clone())
.description(format!("Aired episodes of {}", title))
.pub_date(pub_date)
.last_build_date(last_build_date)
.items(items)
.build()
.unwrap();
eprintln!("INFO: {} ({}) requested", anime_id, title);
Ok(response::Builder::new()
.status(200)
.header("Content-Type", "application/rss+xml")
.body(channel.to_string()))
}
async fn async_main() {
let port = match env::var("PORT") {
Ok(port) => port.parse::<u16>().unwrap(),
Err(_) => 8080
};
let client = Client::new();
let client = warp::any().map(move || client.clone());
let log = warp::log("rss-anime-notifier-rs");
let bare_path = warp::path!(usize).and(client).and_then(give_response).with(log);
let routes = warp::get().and(bare_path);
eprintln!("INFO: Listening on 127.0.0.1:{}", port);
warp::serve(routes).run(([127, 0, 0, 1], port)).await;
}
fn main() {
tokio::runtime::Runtime::new()
.unwrap()
.block_on(async_main());
}