johrpan/musicus
1
0
Fork 0
mirror of https://github.com/johrpan/musicus.git synced 2025-10-26 19:57:25 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Propagate all errors from backend

Browse source
This commit is contained in:
Elias Projahn 2020-10-11 21:30:06 +02:00
parent 711b6d97ff
commit 56c4268e4d
3 changed files with 46 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

91
src/backend.rs
View file

@ -42,111 +42,93 @@ impl Backend {
for action in action_receiver { for action in action_receiver {
match action { match action {
UpdatePerson(person, sender) => { UpdatePerson(person, sender) => {
db.update_person(person);
sender sender
.send(Ok(())) .send(db.update_person(person))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetPerson(id, sender) => { GetPerson(id, sender) => {
let person = db.get_person(id);
sender sender
.send(person) .send(db.get_person(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
DeletePerson(id, sender) => { DeletePerson(id, sender) => {
db.delete_person(id);
sender sender
.send(Ok(())) .send(db.delete_person(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetPersons(sender) => { GetPersons(sender) => {
let persons = db.get_persons();
sender sender
.send(persons) .send(db.get_persons())
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
UpdateInstrument(instrument, sender) => { UpdateInstrument(instrument, sender) => {
db.update_instrument(instrument);
sender sender
.send(Ok(())) .send(db.update_instrument(instrument))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetInstrument(id, sender) => { GetInstrument(id, sender) => {
let instrument = db.get_instrument(id);
sender sender
.send(instrument) .send(db.get_instrument(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
DeleteInstrument(id, sender) => { DeleteInstrument(id, sender) => {
db.delete_instrument(id);
sender sender
.send(Ok(())) .send(db.delete_instrument(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetInstruments(sender) => { GetInstruments(sender) => {
let instruments = db.get_instruments();
sender sender
.send(instruments) .send(db.get_instruments())
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
UpdateWork(work, sender) => { UpdateWork(work, sender) => {
db.update_work(work);
sender sender
.send(Ok(())) .send(db.update_work(work))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetWorkDescriptions(id, sender) => { GetWorkDescriptions(id, sender) => {
let works = db.get_work_descriptions(id);
sender sender
.send(works) .send(db.get_work_descriptions(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
UpdateEnsemble(ensemble, sender) => { UpdateEnsemble(ensemble, sender) => {
db.update_ensemble(ensemble);
sender sender
.send(Ok(())) .send(db.update_ensemble(ensemble))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetEnsemble(id, sender) => { GetEnsemble(id, sender) => {
let ensemble = db.get_ensemble(id);
sender sender
.send(ensemble) .send(db.get_ensemble(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
DeleteEnsemble(id, sender) => { DeleteEnsemble(id, sender) => {
db.delete_ensemble(id);
sender sender
.send(Ok(())) .send(db.delete_ensemble(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetEnsembles(sender) => { GetEnsembles(sender) => {
let ensembles = db.get_ensembles();
sender sender
.send(ensembles) .send(db.get_ensembles())
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
UpdateRecording(recording, sender) => { UpdateRecording(recording, sender) => {
db.update_recording(recording);
sender sender
.send(Ok(())) .send(db.update_recording(recording))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetRecordingsForPerson(id, sender) => { GetRecordingsForPerson(id, sender) => {
let recordings = db.get_recordings_for_person(id);
sender sender
.send(recordings) .send(db.get_recordings_for_person(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetRecordingsForEnsemble(id, sender) => { GetRecordingsForEnsemble(id, sender) => {
let recordings = db.get_recordings_for_ensemble(id);
sender sender
.send(recordings) .send(db.get_recordings_for_ensemble(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
GetRecordingsForWork(id, sender) => { GetRecordingsForWork(id, sender) => {
let recordings = db.get_recordings_for_work(id);
sender sender
.send(recordings) .send(db.get_recordings_for_work(id))
.expect("Failed to send result from database thread!"); .expect("Failed to send result from database thread!");
} }
} }
@ -160,94 +142,95 @@ impl Backend {
pub async fn update_person(&self, person: Person) -> Result<()> { pub async fn update_person(&self, person: Person) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(UpdatePerson(person, sender)); self.action_sender.send(UpdatePerson(person, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_person(&self, id: i64) -> Result<Person> { pub async fn get_person(&self, id: i64) -> Result<Person> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(GetPerson(id, sender)); self.action_sender.send(GetPerson(id, sender))?;
receiver.await? receiver.await?
} }
pub async fn delete_person(&self, id: i64) -> Result<()> { pub async fn delete_person(&self, id: i64) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(DeletePerson(id, sender)); self.action_sender.send(DeletePerson(id, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_persons(&self) -> Result<Vec<Person>> { pub async fn get_persons(&self) -> Result<Vec<Person>> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(GetPersons(sender)); self.action_sender.send(GetPersons(sender))?;
receiver.await? receiver.await?
} }
pub async fn update_instrument(&self, instrument: Instrument) -> Result<()> { pub async fn update_instrument(&self, instrument: Instrument) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender self.action_sender
.send(UpdateInstrument(instrument, sender)); .send(UpdateInstrument(instrument, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_instrument(&self, id: i64) -> Result<Instrument> { pub async fn get_instrument(&self, id: i64) -> Result<Instrument> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(GetInstrument(id, sender)); self.action_sender.send(GetInstrument(id, sender))?;
receiver.await? receiver.await?
} }
pub async fn delete_instrument(&self, id: i64) -> Result<()> { pub async fn delete_instrument(&self, id: i64) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(DeleteInstrument(id, sender)); self.action_sender.send(DeleteInstrument(id, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_instruments(&self) -> Result<Vec<Instrument>> { pub async fn get_instruments(&self) -> Result<Vec<Instrument>> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(GetInstruments(sender)); self.action_sender.send(GetInstruments(sender))?;
receiver.await? receiver.await?
} }
pub async fn update_work(&self, work_insertion: WorkInsertion) -> Result<()> { pub async fn update_work(&self, work_insertion: WorkInsertion) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(UpdateWork(work_insertion, sender)); self.action_sender
.send(UpdateWork(work_insertion, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_work_descriptions(&self, person_id: i64) -> Result<Vec<WorkDescription>> { pub async fn get_work_descriptions(&self, person_id: i64) -> Result<Vec<WorkDescription>> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender self.action_sender
.send(GetWorkDescriptions(person_id, sender)); .send(GetWorkDescriptions(person_id, sender))?;
receiver.await? receiver.await?
} }
pub async fn update_ensemble(&self, ensemble: Ensemble) -> Result<()> { pub async fn update_ensemble(&self, ensemble: Ensemble) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(UpdateEnsemble(ensemble, sender)); self.action_sender.send(UpdateEnsemble(ensemble, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_ensemble(&self, id: i64) -> Result<Ensemble> { pub async fn get_ensemble(&self, id: i64) -> Result<Ensemble> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(GetEnsemble(id, sender)); self.action_sender.send(GetEnsemble(id, sender))?;
receiver.await? receiver.await?
} }
pub async fn delete_ensemble(&self, id: i64) -> Result<()> { pub async fn delete_ensemble(&self, id: i64) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(DeleteEnsemble(id, sender)); self.action_sender.send(DeleteEnsemble(id, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_ensembles(&self) -> Result<Vec<Ensemble>> { pub async fn get_ensembles(&self) -> Result<Vec<Ensemble>> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender.send(GetEnsembles(sender)); self.action_sender.send(GetEnsembles(sender))?;
receiver.await? receiver.await?
} }
pub async fn update_recording(&self, recording_insertion: RecordingInsertion) -> Result<()> { pub async fn update_recording(&self, recording_insertion: RecordingInsertion) -> Result<()> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender self.action_sender
.send(UpdateRecording(recording_insertion, sender)); .send(UpdateRecording(recording_insertion, sender))?;
receiver.await? receiver.await?
} }
@ -257,7 +240,7 @@ impl Backend {
) -> Result<Vec<RecordingDescription>> { ) -> Result<Vec<RecordingDescription>> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender self.action_sender
.send(GetRecordingsForPerson(person_id, sender)); .send(GetRecordingsForPerson(person_id, sender))?;
receiver.await? receiver.await?
} }
@ -267,14 +250,14 @@ impl Backend {
) -> Result<Vec<RecordingDescription>> { ) -> Result<Vec<RecordingDescription>> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender self.action_sender
.send(GetRecordingsForEnsemble(ensemble_id, sender)); .send(GetRecordingsForEnsemble(ensemble_id, sender))?;
receiver.await? receiver.await?
} }
pub async fn get_recordings_for_work(&self, work_id: i64) -> Result<Vec<RecordingDescription>> { pub async fn get_recordings_for_work(&self, work_id: i64) -> Result<Vec<RecordingDescription>> {
let (sender, receiver) = oneshot::channel(); let (sender, receiver) = oneshot::channel();
self.action_sender self.action_sender
.send(GetRecordingsForWork(work_id, sender)); .send(GetRecordingsForWork(work_id, sender))?;
receiver.await? receiver.await?
} }
} }

14
src/database/database.rs
View file

@ -1,7 +1,7 @@
use super::models::*; use super::models::*;
use super::schema::*; use super::schema::*;
use super::tables::*; use super::tables::*;
use anyhow::{anyhow, Result}; use anyhow::{anyhow, Error, Result};
use diesel::prelude::*; use diesel::prelude::*;
embed_migrations!(); embed_migrations!();
@ -84,8 +84,8 @@ impl Database {
let id = work_insertion.work.id; let id = work_insertion.work.id;
self.defer_foreign_keys(); self.defer_foreign_keys();
self.c.transaction(|| { self.c.transaction::<(), Error, _>(|| {
self.delete_work(id); self.delete_work(id)?;
diesel::insert_into(works::table) diesel::insert_into(works::table)
.values(work_insertion.work) .values(work_insertion.work)
@ -125,7 +125,7 @@ impl Database {
.execute(&self.c)?; .execute(&self.c)?;
} }
diesel::result::QueryResult::Ok(()) Ok(())
})?; })?;
Ok(()) Ok(())
@ -267,8 +267,8 @@ impl Database {
let id = recording_insertion.recording.id; let id = recording_insertion.recording.id;
self.defer_foreign_keys(); self.defer_foreign_keys();
self.c.transaction(|| { self.c.transaction::<(), Error, _>(|| {
self.delete_recording(id); self.delete_recording(id)?;
diesel::insert_into(recordings::table) diesel::insert_into(recordings::table)
.values(recording_insertion.recording) .values(recording_insertion.recording)
@ -280,7 +280,7 @@ impl Database {
.execute(&self.c)?; .execute(&self.c)?;
} }
diesel::result::QueryResult::Ok(()) Ok(())
})?; })?;
Ok(()) Ok(())

5
src/window.rs
View file

@ -1,7 +1,6 @@
use super::backend::Backend; use super::backend::Backend;
use super::database::*; use super::database::*;
use super::dialogs::*; use super::dialogs::*;
use futures::prelude::*;
use gio::prelude::*; use gio::prelude::*;
use glib::clone; use glib::clone;
use gtk::prelude::*; use gtk::prelude::*;
@ -603,7 +602,7 @@ impl Window {
.set_visible_child_name("work_details_screen"); .set_visible_child_name("work_details_screen");
self.leaflet.set_visible_child_name("content"); self.leaflet.set_visible_child_name("content");
} }
WorkScreen(poe, work, recordings, search) => { WorkScreen(poe, _, recordings, search) => {
for child in self.work_details_recording_list.get_children() { for child in self.work_details_recording_list.get_children() {
self.work_details_recording_list.remove(&child); self.work_details_recording_list.remove(&child);
} }
@ -664,7 +663,7 @@ impl Window {
.set_visible_child_name("work_details_screen"); .set_visible_child_name("work_details_screen");
self.leaflet.set_visible_child_name("content"); self.leaflet.set_visible_child_name("content");
} }
RecordingScreenLoading(poe, recording) => { RecordingScreenLoading(_, recording) => {
self.recording_details_header self.recording_details_header
.set_title(Some(&recording.work.get_title())); .set_title(Some(&recording.work.get_title()));
self.recording_details_header self.recording_details_header