Revert merging of server and client repository

src/database/works.rs

@@ -0,0 +1,297 @@
+use super::generate_id;
+use super::schema::{instrumentations, work_parts, work_sections, works};
+use super::{Database, Instrument, Person};
+use anyhow::{anyhow, Error, Result};
+use diesel::prelude::*;
+use diesel::{Insertable, Queryable};
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+
+/// Table row data for a work.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "works"]
+struct WorkRow {
+    pub id: String,
+    pub composer: String,
+    pub title: String,
+}
+
+impl From<Work> for WorkRow {
+    fn from(work: Work) -> Self {
+        WorkRow {
+            id: work.id,
+            composer: work.composer.id,
+            title: work.title,
+        }
+    }
+}
+
+/// Definition that a work uses an instrument.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "instrumentations"]
+struct InstrumentationRow {
+    pub id: i64,
+    pub work: String,
+    pub instrument: String,
+}
+
+/// Table row data for a work part.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "work_parts"]
+struct WorkPartRow {
+    pub id: i64,
+    pub work: String,
+    pub part_index: i64,
+    pub title: String,
+    pub composer: Option<String>,
+}
+
+/// Table row data for a work section.
+#[derive(Insertable, Queryable, Debug, Clone)]
+#[table_name = "work_sections"]
+struct WorkSectionRow {
+    pub id: i64,
+    pub work: String,
+    pub title: String,
+    pub before_index: i64,
+}
+/// A concrete work part that can be recorded.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkPart {
+    pub title: String,
+    pub composer: Option<Person>,
+}
+
+/// A heading between work parts.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkSection {
+    pub title: String,
+    pub before_index: usize,
+}
+
+/// A specific work by a composer.
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct Work {
+    pub id: String,
+    pub title: String,
+    pub composer: Person,
+    pub instruments: Vec<Instrument>,
+    pub parts: Vec<WorkPart>,
+    pub sections: Vec<WorkSection>,
+}
+
+impl Work {
+    /// Initialize a new work with a composer.
+    pub fn new(composer: Person) -> Self {
+        Self {
+            id: generate_id(),
+            title: String::new(),
+            composer,
+            instruments: Vec::new(),
+            parts: Vec::new(),
+            sections: Vec::new(),
+        }
+    }
+
+    /// Get a string including the composer and title of the work.
+    // TODO: Replace with impl Display.
+    pub fn get_title(&self) -> String {
+        format!("{}: {}", self.composer.name_fl(), self.title)
+    }
+}
+
+impl Database {
+    /// Update an existing work or insert a new one.
+    // TODO: Think about also inserting related items.
+    pub fn update_work(&self, work: Work) -> Result<()> {
+        self.defer_foreign_keys()?;
+
+        self.connection.transaction::<(), Error, _>(|| {
+            let work_id = &work.id;
+            self.delete_work(work_id)?;
+
+            // Add associated items from the server, if they don't already exist.
+
+            if self.get_person(&work.composer.id)?.is_none() {
+                self.update_person(work.composer.clone())?;
+            }
+
+            for instrument in &work.instruments {
+                if self.get_instrument(&instrument.id)?.is_none() {
+                    self.update_instrument(instrument.clone())?;
+                }
+            }
+
+            for part in &work.parts {
+                if let Some(person) = &part.composer {
+                    if self.get_person(&person.id)?.is_none() {
+                        self.update_person(person.clone())?;
+                    }
+                }
+            }
+
+            // Add the actual work.
+
+            let row: WorkRow = work.clone().into();
+            diesel::insert_into(works::table)
+                .values(row)
+                .execute(&self.connection)?;
+
+            match work {
+                Work {
+                    instruments,
+                    parts,
+                    sections,
+                    ..
+                } => {
+                    for instrument in instruments {
+                        let row = InstrumentationRow {
+                            id: rand::random(),
+                            work: work_id.to_string(),
+                            instrument: instrument.id,
+                        };
+
+                        diesel::insert_into(instrumentations::table)
+                            .values(row)
+                            .execute(&self.connection)?;
+                    }
+
+                    for (index, part) in parts.into_iter().enumerate() {
+                        let row = WorkPartRow {
+                            id: rand::random(),
+                            work: work_id.to_string(),
+                            part_index: index.try_into()?,
+                            title: part.title,
+                            composer: part.composer.map(|person| person.id),
+                        };
+
+                        diesel::insert_into(work_parts::table)
+                            .values(row)
+                            .execute(&self.connection)?;
+                    }
+
+                    for section in sections {
+                        let row = WorkSectionRow {
+                            id: rand::random(),
+                            work: work_id.to_string(),
+                            title: section.title,
+                            before_index: section.before_index.try_into()?,
+                        };
+
+                        diesel::insert_into(work_sections::table)
+                            .values(row)
+                            .execute(&self.connection)?;
+                    }
+                }
+            }
+
+            Ok(())
+        })?;
+
+        Ok(())
+    }
+
+    /// Get an existing work.
+    pub fn get_work(&self, id: &str) -> Result<Option<Work>> {
+        let row = works::table
+            .filter(works::id.eq(id))
+            .load::<WorkRow>(&self.connection)?
+            .first()
+            .cloned();
+
+        let work = match row {
+            Some(row) => Some(self.get_work_data(row)?),
+            None => None,
+        };
+
+        Ok(work)
+    }
+
+    /// Retrieve all available information on a work from related tables.
+    fn get_work_data(&self, row: WorkRow) -> Result<Work> {
+        let mut instruments: Vec<Instrument> = Vec::new();
+
+        let instrumentations = instrumentations::table
+            .filter(instrumentations::work.eq(&row.id))
+            .load::<InstrumentationRow>(&self.connection)?;
+
+        for instrumentation in instrumentations {
+            let id = &instrumentation.instrument;
+            instruments.push(
+                self.get_instrument(id)?
+                    .ok_or(anyhow!("No instrument with ID: {}", id))?,
+            );
+        }
+
+        let mut parts: Vec<WorkPart> = Vec::new();
+
+        let part_rows = work_parts::table
+            .filter(work_parts::work.eq(&row.id))
+            .load::<WorkPartRow>(&self.connection)?;
+
+        for part_row in part_rows {
+            parts.push(WorkPart {
+                title: part_row.title,
+                composer: match part_row.composer {
+                    Some(composer) => Some(
+                        self.get_person(&composer)?
+                            .ok_or(anyhow!("No person with ID: {}", composer))?,
+                    ),
+                    None => None,
+                },
+            });
+        }
+
+        let mut sections: Vec<WorkSection> = Vec::new();
+
+        let section_rows = work_sections::table
+            .filter(work_sections::work.eq(&row.id))
+            .load::<WorkSectionRow>(&self.connection)?;
+
+        for section_row in section_rows {
+            sections.push(WorkSection {
+                title: section_row.title,
+                before_index: section_row.before_index.try_into()?,
+            });
+        }
+
+        let person_id = &row.composer;
+        let person = self
+            .get_person(person_id)?
+            .ok_or(anyhow!("Person doesn't exist: {}", person_id))?;
+
+        Ok(Work {
+            id: row.id,
+            composer: person,
+            title: row.title,
+            instruments,
+            parts,
+            sections,
+        })
+    }
+
+    /// Delete an existing work. This will fail if there are still other tables that relate to
+    /// this work except for the things that are part of the information on the work it
+    pub fn delete_work(&self, id: &str) -> Result<()> {
+        diesel::delete(works::table.filter(works::id.eq(id))).execute(&self.connection)?;
+        Ok(())
+    }
+
+    /// Get all existing works by a composer and related information from other tables.
+    pub fn get_works(&self, composer_id: &str) -> Result<Vec<Work>> {
+        let mut works: Vec<Work> = Vec::new();
+
+        let rows = works::table
+            .filter(works::composer.eq(composer_id))
+            .load::<WorkRow>(&self.connection)?;
+
+        for row in rows {
+            works.push(self.get_work_data(row)?);
+        }
+
+        Ok(works)
+    }
+}