Issue auth

Cargo.toml

@@ -52,6 +52,7 @@ serde_yaml = "0.9"
 lapin = { version = "2.3.1", features = ["serde_json"] }
 futures-lite = "1.13.0"
 clap = { version = "4.4.8", features = ["derive"] }
+serde_path_to_error = "0.1.14"
 
 [dependencies.sqlx]
 version = "0.6.3"

migrations/20230903063840_creating_rating_tables.down.sql

@@ -6,3 +6,5 @@ DROP INDEX idx_obj_id_rating_id;
 
 DROP table rating;
 DROP table product;
+
+DROP TYPE rate_category;

migrations/20230903063840_creating_rating_tables.up.sql

@@ -1,5 +1,17 @@
 -- Add up migration script here
 
+CREATE TYPE rate_category AS ENUM (
+    'application',
+    'cloud',      
+    'stack',
+    'deploymentSpeed',
+    'documentation',
+    'design',
+    'techSupport',
+    'price',
+    'memoryUsage'
+);
+
 CREATE TABLE product (
     id integer NOT NULL, PRIMARY KEY(id),
     obj_id integer NOT NULL,
@@ -12,7 +24,7 @@ CREATE TABLE rating (
     id serial,
     user_id VARCHAR(50) NOT NULL,
     obj_id integer NOT NULL,
-    category VARCHAR(255) NOT NULL,
+    category rate_category NOT NULL,
     comment TEXT DEFAULT NULL,
     hidden BOOLEAN DEFAULT FALSE,
     rate INTEGER,

src/console/commands/appclient/new.rs

@@ -26,7 +26,7 @@ impl crate::console::commands::CallableTrait for NewCommand {
 
             //todo get user from trydirect
             let user = crate::models::user::User {
-                id: "first_name".to_string(),
+                id: format!("{}", self.user_id),
                 first_name: "first_name".to_string(),
                 last_name: "last_name".to_string(),
                 email: "email".to_string(),

src/db/client.rs

@@ -0,0 +1,105 @@
+use sqlx::PgPool;
+use crate::models;
+use tracing::Instrument;
+
+pub async fn update(pool: &PgPool, client: models::Client) -> Result<models::Client, String> {
+    let query_span = tracing::info_span!("Updating client into the database");
+    sqlx::query!(
+        r#"
+        UPDATE client
+        SET 
+            secret=$1,
+            updated_at=NOW() at time zone 'utc'
+        WHERE id = $2
+        "#,
+        client.secret,
+        client.id
+    )
+    .execute(pool)
+    .instrument(query_span)
+    .await
+    .map(|_|{
+        tracing::info!("Client {} have been saved to database", client.id);
+        client
+    })
+    .map_err(|err| {
+        tracing::error!("Failed to execute query: {:?}", err);
+        "".to_string()
+    })
+}
+
+pub async fn fetch(pool: &PgPool, id: i32) -> Result<Option<models::Client>, String> {
+    let query_span = tracing::info_span!("Fetching the client by ID");
+    sqlx::query_as!(
+        models::Client,
+        r#"
+        SELECT
+           id,
+           user_id,
+           secret 
+        FROM client c
+        WHERE c.id = $1
+        LIMIT 1
+        "#,
+        id,
+    )
+    .fetch_one(pool)
+    .instrument(query_span)
+    .await
+    .map(|client| Some(client))
+    .or_else(|e| {
+        match e {
+            sqlx::Error::RowNotFound => Ok(None),
+            s => {
+                tracing::error!("Failed to execute fetch query: {:?}", s);
+                Err("".to_string())
+            }
+        }
+    })
+}
+
+pub async fn count_by_user(pool: &PgPool , user_id: &String) -> Result<i64, String> {
+    let query_span = tracing::info_span!("Counting the user's clients");
+
+    sqlx::query!(
+        r#"
+        SELECT
+            count(*) as client_count
+        FROM client c 
+        WHERE c.user_id = $1
+        "#,
+        user_id.clone(),
+    )
+    .fetch_one(pool)
+    .instrument(query_span)
+    .await
+    .map(|result| {result.client_count.unwrap()})
+    .map_err(|err| {
+        tracing::error!("Failed to execute query: {:?}", err);
+        "Internal Server Error".to_string()
+    })
+}
+
+pub async fn  insert(pool: &PgPool, mut client: models::Client) -> Result<models::Client, String> {
+    let query_span = tracing::info_span!("Saving new client into the database");
+    sqlx::query!(
+        r#"
+        INSERT INTO client (user_id, secret, created_at, updated_at)
+        VALUES ($1, $2, NOW() at time zone 'utc', NOW() at time zone 'utc')
+        RETURNING id
+        "#,
+        client.user_id.clone(),
+        client.secret,
+    )
+    .fetch_one(pool)
+    .instrument(query_span)
+    .await
+    .map(move |result| {
+        client.id = result.id;
+        client
+    })
+    .map_err(|e| {
+        tracing::error!("Failed to execute query: {:?}", e);
+        "Failed to insert".to_string()
+    })
+}

src/db/mod.rs

@@ -0,0 +1,4 @@
+pub mod client;
+pub mod product;
+pub mod rating;
+pub mod stack;

src/db/product.rs

@@ -0,0 +1,30 @@
+use sqlx::PgPool;
+use crate::models;
+use tracing::Instrument;
+
+pub async fn fetch_by_obj(pg_pool: &PgPool, obj_id: i32) -> Result<Option<models::Product>, String> {
+    let query_span = tracing::info_span!("Check product existence by id.");
+    sqlx::query_as!(
+        models::Product,
+        r#"SELECT
+            *
+         FROM product
+         WHERE obj_id = $1
+         LIMIT 1
+         "#,
+        obj_id
+    )
+    .fetch_one(pg_pool)
+    .instrument(query_span)
+    .await
+    .map(|product| Some(product))
+    .or_else(|e| {
+        match e {
+            sqlx::Error::RowNotFound => Ok(None),
+            s => {
+                tracing::error!("Failed to execute fetch query: {:?}", s);
+                Err("".to_string())
+            }
+        }
+    })
+}

src/db/rating.rs

@@ -0,0 +1,133 @@
+use sqlx::PgPool;
+use crate::models;
+use tracing::Instrument;
+
+pub async fn fetch_all(pool: &PgPool) -> Result<Vec<models::Rating>, String> {
+    let query_span = tracing::info_span!("Fetch all ratings.");
+    sqlx::query_as!(
+        models::Rating,
+        r#"SELECT 
+            id,
+            user_id,
+            obj_id,
+            category as "category: _",
+            comment,
+            hidden,
+            rate,
+            created_at,
+            updated_at
+        FROM rating"#
+    )
+    .fetch_all(pool)
+    .instrument(query_span)
+    .await
+    .map_err(|e| {
+        tracing::error!("Failed to execute fetch query: {:?}", e);
+        "".to_string()
+    })
+}
+
+pub async fn fetch(pool: &PgPool, id: i32) -> Result<Option<models::Rating>, String> {
+    let query_span = tracing::info_span!("Fetch rating by id");
+    sqlx::query_as!(
+        models::Rating,
+        r#"SELECT 
+            id,
+            user_id,
+            obj_id,
+            category as "category: _",
+            comment,
+            hidden,
+            rate,
+            created_at,
+            updated_at
+        FROM rating
+        WHERE id=$1
+        LIMIT 1"#,
+        id
+    )
+    .fetch_one(pool)
+    .instrument(query_span)
+    .await
+    .map(|rating| Some(rating))
+    .or_else(|e| {
+        match e {
+            sqlx::Error::RowNotFound => Ok(None),
+            s => {
+                tracing::error!("Failed to execute fetch query: {:?}", s);
+                Err("".to_string())
+            }
+        }
+    })
+}
+
+pub async fn fetch_by_obj_and_user_and_category(
+    pool: &PgPool,
+    obj_id: i32,
+    user_id: String,
+    category: models::RateCategory,
+) -> Result<Option<models::Rating>, String> {
+    let query_span = tracing::info_span!("Fetch rating by obj, user and category.");
+    sqlx::query_as!(
+        models::Rating,
+        r#"SELECT 
+            id,
+            user_id,
+            obj_id,
+            category as "category: _",
+            comment,
+            hidden,
+            rate,
+            created_at,
+            updated_at
+        FROM rating
+        WHERE user_id=$1
+            AND obj_id=$2
+            AND category=$3
+        LIMIT 1"#,
+        user_id,
+        obj_id,
+        category as _ 
+    )
+    .fetch_one(pool)
+    .instrument(query_span)
+    .await
+    .map(|rating| Some(rating))
+    .or_else(|e| {
+        match e {
+            sqlx::Error::RowNotFound => Ok(None),
+            s => {
+                tracing::error!("Failed to execute fetch query: {:?}", s);
+                Err("".to_string())
+            }
+        }
+    })
+}
+
+pub async fn insert(pool: &PgPool, mut rating: models::Rating) -> Result<models::Rating, String> {
+    let query_span = tracing::info_span!("Saving new rating details into the database");
+    sqlx::query!(
+        r#"
+        INSERT INTO rating (user_id, obj_id, category, comment, hidden, rate, created_at, updated_at)
+        VALUES ($1, $2, $3, $4, $5, $6, NOW() at time zone 'utc', NOW() at time zone 'utc')
+        RETURNING id
+        "#,
+        rating.user_id,
+        rating.obj_id,
+        rating.category as _,
+        rating.comment,
+        rating.hidden,
+        rating.rate
+    )
+    .fetch_one(pool)
+    .instrument(query_span)
+    .await
+    .map(move |result| {
+        rating.id = result.id;
+        rating
+    })
+    .map_err(|e| {
+        tracing::error!("Failed to execute query: {:?}", e);
+        "Failed to insert".to_string()
+    })
+}