128 lines
3.5 KiB
Rust
128 lines
3.5 KiB
Rust
use diesel::prelude::*;
|
|
use diesel;
|
|
use rss;
|
|
|
|
use schema;
|
|
use dbqueries;
|
|
use feedparser;
|
|
use errors::*;
|
|
use models::{NewSource, Source, Podcast, Episode};
|
|
|
|
pub fn foo() {
|
|
let inpt = vec![
|
|
"https://request-for-explanation.github.io/podcast/rss.xml",
|
|
"https://feeds.feedburner.com/InterceptedWithJeremyScahill",
|
|
"http://feeds.propublica.org/propublica/podcast",
|
|
"http://feeds.feedburner.com/linuxunplugged",
|
|
];
|
|
|
|
let db = ::establish_connection();
|
|
for feed in inpt.iter() {
|
|
match insert_source(&db, feed) {
|
|
Ok(_) => {}
|
|
Err(foo) => {
|
|
error!("Error: {}", foo);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
index_loop(db).unwrap();
|
|
}
|
|
|
|
fn insert_source(con: &SqliteConnection, url: &str) -> Result<Source> {
|
|
let foo = NewSource::new_with_uri(url);
|
|
|
|
match dbqueries::load_source(con, foo.uri) {
|
|
Ok(mut bar) => {
|
|
// TODO: Cmp first before replacing
|
|
// FIXME: NewSource has None values for etag, and last_mod atm
|
|
// bar.set_http_etag(foo.http_etag);
|
|
// bar.set_last_modified(foo.last_modified);
|
|
// bar.save_changes::<Source>(con)?;
|
|
}
|
|
Err(_) => {
|
|
diesel::insert(&foo).into(schema::source::table).execute(
|
|
con,
|
|
)?;
|
|
}
|
|
}
|
|
|
|
Ok(dbqueries::load_source(con, foo.uri)?)
|
|
}
|
|
|
|
fn index_podcast(
|
|
con: &SqliteConnection,
|
|
channel: &rss::Channel,
|
|
parent: &Source,
|
|
) -> Result<Podcast> {
|
|
let pd = feedparser::parse_podcast(channel, parent.id())?;
|
|
|
|
match dbqueries::load_podcast(con, &pd.title) {
|
|
Ok(mut foo) => {
|
|
// TODO: Cmp first before replacing
|
|
foo.set_link(&pd.link);
|
|
foo.set_description(&pd.description);
|
|
foo.set_image_uri(pd.image_uri.as_ref().map(|s| s.as_str()));
|
|
foo.save_changes::<Podcast>(con)?;
|
|
}
|
|
Err(_) => {
|
|
diesel::insert(&pd).into(schema::podcast::table).execute(
|
|
con,
|
|
)?;
|
|
}
|
|
}
|
|
|
|
Ok(dbqueries::load_podcast(con, &pd.title)?)
|
|
}
|
|
|
|
fn index_episode(con: &SqliteConnection, item: &rss::Item, parent: &Podcast) -> Result<Episode> {
|
|
let ep = feedparser::parse_episode(item, parent.id())?;
|
|
|
|
match dbqueries::load_episode(con, &ep.uri.unwrap()) {
|
|
Ok(mut foo) => {
|
|
// TODO: Cmp first before replacing
|
|
foo.set_title(ep.title);
|
|
foo.set_description(ep.description);
|
|
foo.set_published_date(ep.published_date);
|
|
foo.set_guid(ep.guid);
|
|
foo.set_length(ep.length);
|
|
foo.set_epoch(ep.epoch);
|
|
foo.save_changes::<Episode>(con)?;
|
|
}
|
|
Err(_) => {
|
|
diesel::insert(&ep).into(schema::episode::table).execute(
|
|
con,
|
|
)?;
|
|
}
|
|
}
|
|
|
|
Ok(dbqueries::load_episode(con, &ep.uri.unwrap())?)
|
|
}
|
|
|
|
pub fn index_loop(db: SqliteConnection) -> Result<()> {
|
|
// let db = ::establish_connection();
|
|
|
|
let f = dbqueries::get_sources(&db);
|
|
|
|
for feed in f.unwrap().iter_mut() {
|
|
// info!("{:?}", feed.id());
|
|
|
|
// This method will defently get split and nuked
|
|
// but for now its poc
|
|
let chan = feed.get_podcast_chan(&db)?;
|
|
|
|
let pd = index_podcast(&db, &chan, &feed)?;
|
|
|
|
let _: Vec<_> = chan.items()
|
|
.iter()
|
|
.map(|x| index_episode(&db, &x, &pd))
|
|
.collect();
|
|
|
|
info!("{:#?}", pd);
|
|
// info!("{:#?}", episodes);
|
|
// info!("{:?}", chan);
|
|
|
|
}
|
|
Ok(())
|
|
} |