1 files changed, 81 insertions, 56 deletions

diff --git a/src/db.rs b/src/db.rs
index 6bce5e8..a5341f1 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -23,16 +23,16 @@ use crate::{
 
 use diesel::prelude::*;
 
-use rocket_contrib::{
+use rocket_sync_db_pools::{
     database,
-    databases::diesel,
+    diesel,
 };
 
 #[database("main")]
 pub struct Connection(diesel::PgConnection);
 
 impl Connection {
-    pub fn create_screening(
+    pub async fn create_screening(
         &self,
         room_id: i32,
         film_id: i32,
@@ -40,22 +40,24 @@ impl Connection {
         end_time: chrono::DateTime<chrono::Utc>) -> QueryResult<usize>
     {
         let s = models::NewScreening { room_id, film_id, start_time, end_time };
-        diesel::insert_into(screenings::table)
-            .values(&s)
-            .execute(&**self)
+        self.run(move |conn| {
+            diesel::insert_into(screenings::table)
+                .values(&s)
+                .execute(conn)
+        }).await
     }
 
-    pub fn create_screening_from_aggregate(
+    pub async fn create_screening_from_aggregate(
         &self,
         room: &models::Room,
         film: &models::Film,
         start_time: chrono::DateTime<chrono::Utc>,
         end_time: chrono::DateTime<chrono::Utc>) -> QueryResult<usize>
     {
-        self.create_screening(room.id, film.id, start_time, end_time)
+        self.create_screening(room.id, film.id, start_time, end_time).await
     }
 
-    pub fn update_screening(
+    pub async fn update_screening(
         &self,
         screening_id: i32,
         room_id: i32,
@@ -64,72 +66,95 @@ impl Connection {
         end_time: chrono::DateTime<chrono::Utc>) -> QueryResult<usize>
     {
         let s = models::Screening { id: screening_id, film_id, room_id, start_time, end_time };
-        diesel::update(screenings::table)
-            .filter(screenings::id.eq(screening_id))
-            .set(&s)
-            .execute(&**self)
+        self.run(move |conn| {
+            diesel::update(screenings::table)
+                .filter(screenings::id.eq(screening_id))
+                .set(&s)
+                .execute(conn)
+        }).await
     }
 
-    pub fn get_screenings(&self) -> QueryResult<Vec<models::Screening>> {
-        use crate::schema::screenings::dsl::*;
-        screenings.load(&**self)
+    pub async fn get_screenings(&self) -> QueryResult<Vec<models::Screening>> {
+        self.run(|conn| {
+            use crate::schema::screenings::dsl::*;
+            screenings.load(conn)
+        }).await
     }
 
-    pub fn get_screening(&self, screening_id: i32) -> QueryResult<models::Screening> {
-        use crate::schema::screenings::dsl::*;
-        screenings.filter(id.eq(screening_id)).get_result(&**self)
+    pub async fn get_screening(&self, screening_id: i32) -> QueryResult<models::Screening> {
+        self.run(move |conn| {
+            use crate::schema::screenings::dsl::*;
+            screenings.filter(id.eq(screening_id)).get_result(conn)
+        }).await
     }
 
-    pub fn get_aggregated_screenings(&self) -> QueryResult<Vec<models::AggregatedScreening>> {
-        use crate::schema::screenings::dsl::*;
-        let s = screenings
-            .left_join(films::table)
-            .left_join(rooms::table)
-            .get_results(&**self)?;
-        Ok(models::AggregatedScreening::from_query(s))
+    pub async fn get_aggregated_screenings(&self) -> QueryResult<Vec<models::AggregatedScreening>> {
+        let s = self.run(|conn| {
+            use crate::schema::screenings::dsl::*;
+            screenings
+                .left_join(films::table)
+                .left_join(rooms::table)
+                .get_results(conn)
+        }).await;
+
+        Ok(models::AggregatedScreening::from_query(s?))
     }
 
-    pub fn delete_screening(&self, screening_id: i32) -> QueryResult<usize> {
-        use crate::schema::screenings::dsl::*;
-        diesel::delete(screenings.filter(id.eq(screening_id)))
-            .execute(&**self)
+    pub async fn delete_screening(&self, screening_id: i32) -> QueryResult<usize> {
+        self.run(move |conn| {
+            use crate::schema::screenings::dsl::*;
+            diesel::delete(screenings.filter(id.eq(screening_id)))
+                .execute(conn)
+        }).await
     }
 
-    pub fn create_room(&self, room_name: &String) -> QueryResult<usize> {
-        use crate::schema::rooms::dsl::*;
-        diesel::insert_into(rooms)
-            .values(&name.eq(room_name))
-            .execute(&**self)
+    pub async fn create_room(&self, room_name: String) -> QueryResult<usize> {
+        self.run(move |conn| {
+            use crate::schema::rooms::dsl::*;
+            diesel::insert_into(rooms)
+                .values(&name.eq(room_name))
+                .execute(conn)
+        }).await
     }
 
-    pub fn get_rooms(&self) -> QueryResult<Vec<models::Room>> {
-        use crate::schema::rooms::dsl::*;
-        rooms.load(&**self)
+    pub async fn get_rooms(&self) -> QueryResult<Vec<models::Room>> {
+        self.run(|conn| {
+            use crate::schema::rooms::dsl::*;
+            rooms.load(conn)
+        }).await
     }
 
-    pub fn get_room_by_name(&self, room_name: &str) -> QueryResult<models::Room> {
-        use crate::schema::rooms::dsl::*;
-        rooms
-            .filter(name.eq(&room_name))
-            .get_result(&**self)
+    pub async fn get_room_by_name(&self, room_name: String) -> QueryResult<models::Room> {
+        self.run(move |conn| {
+            use crate::schema::rooms::dsl::*;
+            rooms
+                .filter(name.eq(&room_name))
+                .get_result(conn)
+        }).await
     }
 
-    pub fn create_film(&self, film_title: &str, film_url: &Option<String>) -> QueryResult<usize> {
-        use crate::schema::films::dsl::*;
-        diesel::insert_into(films)
-            .values(&(title.eq(film_title), url.eq(film_url)))
-            .execute(&**self)
+    pub async fn create_film(&self, film_title: String, film_url: Option<String>) -> QueryResult<usize> {
+        self.run(move |conn| {
+            use crate::schema::films::dsl::*;
+            diesel::insert_into(films)
+                .values(&(title.eq(film_title), url.eq(film_url)))
+                .execute(conn)
+        }).await
     }
 
-    pub fn get_films(&self) -> QueryResult<Vec<models::Film>> {
-        use crate::schema::films::dsl::*;
-        films.load(&**self)
+    pub async fn get_films(&self) -> QueryResult<Vec<models::Film>> {
+        self.run(|conn| {
+            use crate::schema::films::dsl::*;
+            films.load(conn)
+        }).await
     }
 
-    pub fn get_film_by_title(&self, film_title: &str) -> QueryResult<models::Film> {
-        use crate::schema::films::dsl::*;
-        films
-            .filter(title.eq(&film_title))
-            .get_result(&**self)
+    pub async fn get_film_by_title(&self, film_title: String) -> QueryResult<models::Film> {
+        self.run(move |conn| {
+            use crate::schema::films::dsl::*;
+            films
+                .filter(title.eq(&film_title))
+                .get_result(conn)
+        }).await
     }
 }