toxblh/podcasts
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Partial cleanup of dbqueries.

Browse Source
This commit is contained in:
Jordan Petridis 2017-11-05 14:56:24 +02:00
parent 27c73e3d30
commit 7b5bca2162
No known key found for this signature in database
GPG Key ID: CEABAD9F5683B9A6
6 changed files with 73 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hammond-data/src/dbcheckup.rs
View File

@ -49,6 +49,8 @@ fn played_cleaner(db: &Database) -> Result<()> {
if let Err(err) = e {
error!("Error while trying to delete file: {:?}", ep.local_uri());
error!("Error: {}", err);
} else {
info!("Episode {:?} was deleted succesfully.", ep.title());
};
}
}

120
hammond-data/src/dbqueries.rs
View File

@ -1,91 +1,82 @@
#![cfg_attr(feature = "cargo-clippy", allow(let_and_return))]
use diesel::prelude::*;
use diesel;
use models::{Episode, Podcast, Source};
use index_feed::Database;
use errors::*;
use chrono::prelude::*;
/// Random db querries helper functions.
/// Probably needs cleanup.
pub fn get_sources(con: &SqliteConnection) -> QueryResult<Vec<Source>> {
use schema::source::dsl::*;
let s = source.load::<Source>(con);
s
source.load::<Source>(con)
}
pub fn get_podcasts(con: &SqliteConnection) -> QueryResult<Vec<Podcast>> {
use schema::podcast::dsl::*;
let pds = podcast.load::<Podcast>(con);
pds
podcast.load::<Podcast>(con)
}
pub fn get_episodes(con: &SqliteConnection) -> QueryResult<Vec<Episode>> {
use schema::episode::dsl::*;
let eps = episode.order(epoch.desc()).load::<Episode>(con);
eps
episode.order(epoch.desc()).load::<Episode>(con)
}
pub fn get_downloaded_episodes(con: &SqliteConnection) -> QueryResult<Vec<Episode>> {
use schema::episode::dsl::*;
let eps = episode.filter(local_uri.is_not_null()).load::<Episode>(con);
eps
episode.filter(local_uri.is_not_null()).load::<Episode>(con)
}
pub fn get_played_episodes(con: &SqliteConnection) -> QueryResult<Vec<Episode>> {
use schema::episode::dsl::*;
let eps = episode.filter(played.is_not_null()).load::<Episode>(con);
eps
episode.filter(played.is_not_null()).load::<Episode>(con)
}
pub fn get_episode(con: &SqliteConnection, ep_id: i32) -> QueryResult<Episode> {
pub fn get_episode_from_id(con: &SqliteConnection, ep_id: i32) -> QueryResult<Episode> {
use schema::episode::dsl::*;
let ep = episode.filter(id.eq(ep_id)).get_result::<Episode>(con);
ep
episode.filter(id.eq(ep_id)).get_result::<Episode>(con)
}
pub fn get_episode_local_uri(con: &SqliteConnection, ep_id: i32) -> QueryResult<Option<String>> {
pub fn get_episode_local_uri_from_id(
con: &SqliteConnection,
ep_id: i32,
) -> QueryResult<Option<String>> {
use schema::episode::dsl::*;
let ep = episode
episode
.filter(id.eq(ep_id))
.select(local_uri)
.get_result::<Option<String>>(con);
ep
.get_result::<Option<String>>(con)
}
pub fn get_episodes_with_limit(con: &SqliteConnection, limit: u32) -> QueryResult<Vec<Episode>> {
use schema::episode::dsl::*;
let eps = episode
episode
.order(epoch.desc())
.limit(i64::from(limit))
.load::<Episode>(con);
eps
.load::<Episode>(con)
}
pub fn get_podcast_from_id(con: &SqliteConnection, pid: i32) -> QueryResult<Podcast> {
use schema::podcast::dsl::*;
let pd = podcast.filter(id.eq(pid)).get_result::<Podcast>(con);
pd
podcast.filter(id.eq(pid)).get_result::<Podcast>(con)
}
pub fn get_pd_episodes(con: &SqliteConnection, parent: &Podcast) -> QueryResult<Vec<Episode>> {
use schema::episode::dsl::*;
let eps = Episode::belonging_to(parent)
Episode::belonging_to(parent)
.order(epoch.desc())
.load::<Episode>(con);
eps
.load::<Episode>(con)
}
pub fn get_pd_unplayed_episodes(
@ -94,11 +85,10 @@ pub fn get_pd_unplayed_episodes(
) -> QueryResult<Vec<Episode>> {
use schema::episode::dsl::*;
let eps = Episode::belonging_to(parent)
Episode::belonging_to(parent)
.filter(played.is_null())
.order(epoch.desc())
.load::<Episode>(con);
eps
.load::<Episode>(con)
}
pub fn get_pd_episodes_limit(
@ -108,79 +98,71 @@ pub fn get_pd_episodes_limit(
) -> QueryResult<Vec<Episode>> {
use schema::episode::dsl::*;
let eps = Episode::belonging_to(parent)
Episode::belonging_to(parent)
.order(epoch.desc())
.limit(i64::from(limit))
.load::<Episode>(con);
eps
.load::<Episode>(con)
}
pub fn load_source_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<Source> {
pub fn get_source_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<Source> {
use schema::source::dsl::*;
let s = source.filter(uri.eq(uri_)).get_result::<Source>(con);
s
source.filter(uri.eq(uri_)).get_result::<Source>(con)
}
pub fn load_podcast_from_title(con: &SqliteConnection, title_: &str) -> QueryResult<Podcast> {
pub fn get_podcast_from_title(con: &SqliteConnection, title_: &str) -> QueryResult<Podcast> {
use schema::podcast::dsl::*;
let pd = podcast.filter(title.eq(title_)).get_result::<Podcast>(con);
pd
podcast.filter(title.eq(title_)).get_result::<Podcast>(con)
}
pub fn load_episode_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<Episode> {
pub fn get_episode_from_uri(con: &SqliteConnection, uri_: &str) -> QueryResult<Episode> {
use schema::episode::dsl::*;
let ep = episode.filter(uri.eq(uri_)).get_result::<Episode>(con);
ep
episode.filter(uri.eq(uri_)).get_result::<Episode>(con)
}
pub fn remove_feed(db: &Database, pd: &Podcast) -> Result<()> {
let s_id = pd.source_id();
let pd_id = pd.id();
pub fn remove_feed(db: &Database, pd: &Podcast) -> QueryResult<usize> {
let tempdb = db.lock().unwrap();
tempdb.transaction(|| -> Result<()> {
delete_source(&tempdb, s_id)?;
delete_podcast(&tempdb, pd_id)?;
delete_podcast_episodes(&tempdb, pd_id)?;
Ok(())
})?;
Ok(())
tempdb.transaction(|| -> QueryResult<usize> {
delete_source(&tempdb, pd.source_id())?;
delete_podcast(&tempdb, pd.id())?;
delete_podcast_episodes(&tempdb, pd.id())
})
}
pub fn delete_source(connection: &SqliteConnection, source_id: i32) -> Result<()> {
pub fn delete_source(connection: &SqliteConnection, source_id: i32) -> QueryResult<usize> {
use schema::source::dsl::*;
diesel::delete(source.filter(id.eq(source_id))).execute(connection)?;
Ok(())
diesel::delete(source.filter(id.eq(source_id))).execute(connection)
}
pub fn delete_podcast(connection: &SqliteConnection, podcast_id: i32) -> Result<()> {
pub fn delete_podcast(connection: &SqliteConnection, podcast_id: i32) -> QueryResult<usize> {
use schema::podcast::dsl::*;
diesel::delete(podcast.filter(id.eq(podcast_id))).execute(connection)?;
Ok(())
diesel::delete(podcast.filter(id.eq(podcast_id))).execute(connection)
}
pub fn delete_podcast_episodes(connection: &SqliteConnection, parent_id: i32) -> Result<()> {
pub fn delete_podcast_episodes(
connection: &SqliteConnection,
parent_id: i32,
) -> QueryResult<usize> {
use schema::episode::dsl::*;
diesel::delete(episode.filter(podcast_id.eq(parent_id))).execute(connection)?;
Ok(())
diesel::delete(episode.filter(podcast_id.eq(parent_id))).execute(connection)
}
pub fn update_none_to_played_now(connection: &SqliteConnection, parent: &Podcast) -> Result<()> {
pub fn update_none_to_played_now(
connection: &SqliteConnection,
parent: &Podcast,
) -> QueryResult<usize> {
use schema::episode::dsl::*;
let epoch_now = Utc::now().timestamp() as i32;
connection.transaction(|| -> Result<()> {
connection.transaction(|| -> QueryResult<usize> {
diesel::update(Episode::belonging_to(parent).filter(played.is_null()))
.set(played.eq(Some(epoch_now)))
.execute(connection)?;
Ok(())
})?;
Ok(())
.execute(connection)
})
}

40
hammond-data/src/index_feed.rs
View File

@ -1,5 +1,3 @@
#![allow(dead_code)]
use diesel::prelude::*;
use diesel;
use rss;
@ -19,20 +17,15 @@ pub struct Feed(pub reqwest::Response, pub Source);
pub type Database = Arc<Mutex<SqliteConnection>>;
fn index_source(con: &SqliteConnection, foo: &NewSource) -> Result<()> {
match dbqueries::load_source_from_uri(con, foo.uri) {
Ok(_) => Ok(()),
Err(_) => {
diesel::insert(foo)
.into(schema::source::table)
.execute(con)?;
Ok(())
}
fn index_source(con: &SqliteConnection, foo: &NewSource) -> QueryResult<usize> {
match dbqueries::get_source_from_uri(con, foo.uri) {
Ok(_) => Ok(1),
Err(_) => diesel::insert(foo).into(schema::source::table).execute(con),
}
}
fn index_podcast(con: &SqliteConnection, pd: &NewPodcast) -> Result<()> {
match dbqueries::load_podcast_from_title(con, &pd.title) {
match dbqueries::get_podcast_from_title(con, &pd.title) {
Ok(mut foo) => if foo.link() != pd.link || foo.description() != pd.description {
foo.set_link(&pd.link);
foo.set_description(&pd.description);
@ -49,7 +42,7 @@ fn index_podcast(con: &SqliteConnection, pd: &NewPodcast) -> Result<()> {
}
fn index_episode(con: &SqliteConnection, ep: &NewEpisode) -> Result<()> {
match dbqueries::load_episode_from_uri(con, ep.uri.unwrap()) {
match dbqueries::get_episode_from_uri(con, ep.uri.unwrap()) {
Ok(mut foo) => if foo.title() != ep.title
|| foo.published_date() != ep.published_date.as_ref().map(|x| x.as_str())
{
@ -74,20 +67,20 @@ pub fn insert_return_source(con: &SqliteConnection, url: &str) -> Result<Source>
let foo = NewSource::new_with_uri(url);
index_source(con, &foo)?;
Ok(dbqueries::load_source_from_uri(con, foo.uri)?)
Ok(dbqueries::get_source_from_uri(con, foo.uri)?)
}
fn insert_return_podcast(con: &SqliteConnection, pd: &NewPodcast) -> Result<Podcast> {
index_podcast(con, pd)?;
Ok(dbqueries::load_podcast_from_title(con, &pd.title)?)
Ok(dbqueries::get_podcast_from_title(con, &pd.title)?)
}
fn insert_return_episode(con: &SqliteConnection, ep: &NewEpisode) -> Result<Episode> {
index_episode(con, ep)?;
// fn insert_return_episode(con: &SqliteConnection, ep: &NewEpisode) -> Result<Episode> {
// index_episode(con, ep)?;
Ok(dbqueries::load_episode_from_uri(con, ep.uri.unwrap())?)
}
// Ok(dbqueries::get_episode_from_uri(con, ep.uri.unwrap())?)
// }
pub fn full_index_loop(db: &Database) -> Result<()> {
let mut f = fetch_all_feeds(db)?;
@ -120,9 +113,7 @@ pub fn complete_index_from_source(
req.read_to_string(&mut buf)?;
let chan = rss::Channel::from_str(&buf)?;
complete_index(db, &chan, source)?;
Ok(())
complete_index(db, &chan, source)
}
fn complete_index(db: &Database, chan: &rss::Channel, parent: &Source) -> Result<()> {
@ -137,8 +128,7 @@ fn complete_index(db: &Database, chan: &rss::Channel, parent: &Source) -> Result
fn index_channel(con: &SqliteConnection, chan: &rss::Channel, parent: &Source) -> Result<Podcast> {
let pd = feedparser::parse_podcast(chan, parent.id());
// Convert NewPodcast to Podcast
let pd = insert_return_podcast(con, &pd)?;
Ok(pd)
insert_return_podcast(con, &pd)
}
fn index_channel_items(db: &Database, it: &[rss::Item], pd: &Podcast) {
@ -280,7 +270,7 @@ mod tests {
inpt.iter().for_each(|feed| {
let tempdb = db.lock().unwrap();
index_source(&tempdb, &NewSource::new_with_uri(feed)).unwrap()
index_source(&tempdb, &NewSource::new_with_uri(feed)).unwrap();
});
full_index_loop(&db).unwrap();

5
hammond-data/src/lib.rs
View File

@ -1,6 +1,5 @@
#![recursion_limit = "1024"]
#![cfg_attr(feature = "cargo-clippy", allow(blacklisted_name))]
#![allow(dead_code)]
#[macro_use]
extern crate error_chain;
@ -39,12 +38,12 @@ use std::path::PathBuf;
embed_migrations!("migrations/");
lazy_static!{
#[allow(dead_code)]
static ref HAMMOND_XDG: xdg::BaseDirectories = {
xdg::BaseDirectories::with_prefix("Hammond").unwrap()
};
static ref HAMMOND_DATA: PathBuf = {
static ref _HAMMOND_DATA: PathBuf = {
HAMMOND_XDG.create_data_directory(HAMMOND_XDG.get_data_home()).unwrap()
};

2
hammond-gtk/src/views/podcasts_view.rs
View File

@ -145,5 +145,5 @@ fn init_flowbox(db: &Database, stack: &gtk::Stack, flowbox: &gtk::FlowBox) {
on_flowbox_child_activate(&db, &stack, &parent);
}));
// Populate the flowbox with the Podcasts.
populate_flowbox(db, stack, &flowbox);
populate_flowbox(db, stack, flowbox);
}

4
hammond-gtk/src/widgets/episode.rs
View File

@ -152,7 +152,7 @@ fn on_download_clicked(
fn on_play_bttn_clicked(db: &Database, episode_id: i32) {
let local_uri = {
let tempdb = db.lock().unwrap();
dbqueries::get_episode_local_uri(&tempdb, episode_id).unwrap()
dbqueries::get_episode_local_uri_from_id(&tempdb, episode_id).unwrap()
};
if let Some(uri) = local_uri {
@ -175,7 +175,7 @@ fn on_play_bttn_clicked(db: &Database, episode_id: i32) {
fn on_delete_bttn_clicked(db: &Database, episode_id: i32) {
let mut ep = {
let tempdb = db.lock().unwrap();
dbqueries::get_episode(&tempdb, episode_id).unwrap()
dbqueries::get_episode_from_id(&tempdb, episode_id).unwrap()
};
let e = delete_local_content(db, &mut ep);