Feature: Implement Item API (#20)

Cargo.toml

@@ -7,7 +7,8 @@ edition = "2021"
 
 [dependencies]
 actix-web = "4.4.0"
-diesel = { version = "2.1.4", features = ["postgres", "r2d2"] }
+chrono = "0.4.31"
+diesel = { version = "2.1.4", features = ["postgres", "r2d2", "chrono", "uuid"] }
 diesel_migrations = "2.1.0"
 dotenvy = "0.15.7"
 dotenv = "0.15.0"

README.md

@@ -15,6 +15,10 @@ Run Migration
 
 ``diesel migration run``
 
+Undo Migration
+
+``diesel migration redo``
+
 Run Cargo
 
 ``cargo run``

migrations/2024-01-07-051817_create_items/down.sql

@@ -0,0 +1,2 @@
+-- This file should undo anything in `up.sql`
+DROP table items

migrations/2024-01-07-051817_create_items/up.sql

@@ -0,0 +1,11 @@
+-- Your SQL goes here
+CREATE TABLE items (
+  id VARCHAR NOT NULL PRIMARY KEY,
+  room_id VARCHAR NOT NULL REFERENCES rooms(id) on DELETE CASCADE,
+  name VARCHAR NOT NULL,
+  description VARCHAR,
+  category VARCHAR NOT NULL,
+  purchase_date Timestamp NOT NULL,
+  expiry_date Timestamp,
+  value DOUBLE PRECISION NOT NULL
+)

src/app/actions/item.rs

@@ -0,0 +1,53 @@
+use actix_web::web::Json;
+use diesel::prelude::*;
+use uuid::Uuid;
+
+use crate::app::models::item;
+
+type DbError = Box<dyn std::error::Error + Send + Sync>;
+
+pub fn list_items(conn: &mut PgConnection, uid: Uuid) -> Result<Vec<item::Item>, DbError> {
+    use crate::schema::items::dsl::*;
+
+    let item_list = items.filter(room_id.eq(uid.to_string())).load(conn)?;
+
+    Ok(item_list)
+}
+
+pub fn insert_new_item(
+    conn: &mut PgConnection,
+    form: &Json<item::NewItem>,
+) -> Result<item::Item, DbError> {
+    use crate::schema::items::dsl::*;
+
+    match form.validate() {
+        Ok(_) => {
+            let new_item = item::Item {
+                id: Uuid::new_v4().to_string(),
+                room_id: form.room_id.to_owned(),
+                name: form.name.to_owned(),
+                description: form.description.to_owned(),
+                category: form.category.to_owned(),
+                purchase_date: form.purchase_date.to_owned(),
+                expiry_date: form.expiry_date.to_owned(),
+                value: form.value.to_owned(),
+            };
+
+            diesel::insert_into(items).values(&new_item).execute(conn)?;
+
+            Ok(new_item)
+        }
+        Err(error) => Err(DbError::from(error)),
+    }
+}
+
+pub fn delete_item(conn: &mut PgConnection, uid: Uuid) -> Result<String, DbError> {
+    use crate::schema::items::dsl::*;
+
+    let result = diesel::delete(items.filter(id.eq(uid.to_string()))).execute(conn);
+
+    match result {
+        Ok(_) => Ok("Success".to_string()),
+        Err(e) => Err(DbError::from(e)),
+    }
+}

src/app/actions/mod.rs

@@ -1,2 +1,3 @@
 pub mod home;
 pub mod room;
+pub mod item;

src/app/api/item.rs

@@ -0,0 +1,39 @@
+use actix_web::{error, get, post, web, HttpResponse, Responder, Result};
+use diesel::{r2d2, PgConnection};
+
+use crate::app::actions;
+use crate::app::models;
+
+type DbPool = r2d2::Pool<r2d2::ConnectionManager<PgConnection>>;
+
+#[post("/item")]
+async fn add_item(
+    pool: web::Data<DbPool>,
+    form: web::Json<models::item::NewItem>,
+) -> Result<impl Responder> {
+    let response = web::block(move || {
+        let mut conn = pool.get()?;
+        actions::item::insert_new_item(&mut conn, &form)
+    })
+    .await?
+    .map_err(error::ErrorBadRequest)?;
+
+    Ok(HttpResponse::Created().json(response))
+}
+
+#[get("/item")]
+async fn get_items(
+  pool: web::Data<DbPool>,
+  query: web::Query<models::item::ItemQuery>,
+) -> Result<impl Responder> {
+  let room_uid = query.room_id;
+
+  let response = web::block(move || {
+    let mut conn = pool.get()?;
+    actions::item::list_items(&mut conn, room_uid)
+  })
+  .await?
+  .map_err(error::ErrorBadRequest)?;
+
+  Ok(HttpResponse::Ok().json(response))
+}

src/app/api/mod.rs

@@ -1,2 +1,3 @@
 pub mod home;
 pub mod room;
+pub mod item;

src/app/mod.rs

@@ -5,4 +5,5 @@ pub mod db;
 pub mod models {
   pub mod home;
   pub mod room;
+  pub mod item;
 }

src/app/models/item.rs

@@ -0,0 +1,49 @@
+use diesel::prelude::*;
+use diesel::{prelude::Insertable, Queryable};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::schema::items;
+use crate::app::models::room::Room;
+
+/// Item details.
+#[derive(Queryable, Serialize, Selectable, Identifiable, Associations, Debug, PartialEq, Insertable)]
+#[diesel(belongs_to(Room))]
+#[diesel(table_name = items)]
+pub struct Item {
+    pub id: String,
+    pub name: String,
+    pub room_id: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub purchase_date: String,
+    pub expiry_date: Option<String>,
+    pub value: f64
+}
+
+/// New Item.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NewItem {
+    pub name: String,
+    pub room_id: String,
+    pub description: Option<String>,
+    pub category: String,
+    pub purchase_date: String,
+    pub expiry_date: Option<String>,
+    pub value: f64
+}
+
+#[derive(Deserialize)]
+pub struct ItemQuery {
+    pub room_id: Uuid,
+}
+
+// validations
+impl NewItem {
+  pub fn validate(&self) -> Result<(), String> {
+      if self.name.trim().is_empty() {
+          return Err("Name is empty".to_string());
+      }
+      Ok(())
+  }
+}

src/main.rs

@@ -11,6 +11,7 @@ use app::api::home::{
 };
 
 use app::api::room::{add_room, get_room};
+use app::api::item::{add_item, get_items};
 
 use app::db::{
   initialize_db_pool,
@@ -41,6 +42,8 @@ async fn main() -> std::io::Result<()> {
         .service(delete_home)
         .service(add_room)
         .service(get_room)
+        .service(get_items)
+        .service(add_item)
     })
     .bind(("127.0.0.1", 8080))?
     .run()

src/schema.rs

@@ -8,6 +8,19 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    items (id) {
+        id -> Varchar,
+        room_id -> Varchar,
+        name -> Varchar,
+        description -> Nullable<Varchar>,
+        category -> Varchar,
+        purchase_date -> Varchar,
+        expiry_date -> Nullable<Varchar>,
+        value -> Float8,
+    }
+}
+
 diesel::table! {
     rooms (id) {
         id -> Varchar,
@@ -16,9 +29,11 @@ diesel::table! {
     }
 }
 
+diesel::joinable!(items -> rooms (room_id));
 diesel::joinable!(rooms -> homes (home_id));
 
 diesel::allow_tables_to_appear_in_same_query!(
     homes,
+    items,
     rooms,
 );