[client]: adding trash record as delete view

backend/src/service/trash/router.rs

@@ -14,10 +14,11 @@ use flowy_net::{
     response::FlowyResponse,
 };
 use flowy_workspace::{
-    entities::trash::parser::{TrashId, TrashIds, TrashTypeParser},
+    entities::trash::parser::{TrashId, TrashTypeParser},
     protobuf::{CreateTrashParams, TrashIdentifiers},
 };
 use sqlx::PgPool;
+use uuid::Uuid;
 
 pub async fn create_handler(
     payload: Payload,
@@ -30,9 +31,9 @@ pub async fn create_handler(
         .await
         .context("Failed to acquire a Postgres connection to create trash")?;
 
-    let trash_id = TrashId::parse(params.id).map_err(invalid_params)?;
+    let trash_id = check_trash_id(params.id)?;
     let ty = TrashTypeParser::parse(params.ty.value()).map_err(invalid_params)?;
-    let _ = create_trash(&mut transaction, trash_id.as_ref(), ty, logged_user).await?;
+    let _ = create_trash(&mut transaction, trash_id, ty, logged_user).await?;
 
     transaction
         .commit()
@@ -49,8 +50,8 @@ pub async fn delete_handler(payload: Payload, pool: Data<PgPool>) -> Result<Http
         .await
         .context("Failed to acquire a Postgres connection to delete trash")?;
 
-    let trash_ids = TrashIds::parse(params.ids.into_vec()).map_err(invalid_params)?;
-    let _ = delete_trash(&mut transaction, trash_ids.0).await?;
+    let trash_ids = check_trash_ids(params.ids.into_vec())?;
+    let _ = delete_trash(&mut transaction, trash_ids).await?;
     transaction
         .commit()
         .await
@@ -65,7 +66,7 @@ pub async fn read_handler(pool: Data<PgPool>, logged_user: LoggedUser) -> Result
         .await
         .context("Failed to acquire a Postgres connection to read trash")?;
 
-    let repeated_trash = read_trash(&mut transaction, logged_user).await?;
+    let repeated_trash = read_trash(&mut transaction, &logged_user).await?;
 
     transaction
         .commit()
@@ -74,3 +75,17 @@ pub async fn read_handler(pool: Data<PgPool>, logged_user: LoggedUser) -> Result
 
     Ok(FlowyResponse::success().pb(repeated_trash)?.into())
 }
+
+fn check_trash_id(id: String) -> Result<Uuid, ServerError> {
+    let trash_id = TrashId::parse(id).map_err(invalid_params)?;
+    let trash_id = Uuid::parse_str(trash_id.as_ref())?;
+    Ok(trash_id)
+}
+
+fn check_trash_ids(ids: Vec<String>) -> Result<Vec<Uuid>, ServerError> {
+    let mut trash_ids = vec![];
+    for id in ids {
+        trash_ids.push(check_trash_id(id)?)
+    }
+    Ok(trash_ids)
+}

backend/src/service/trash/trash.rs

@@ -4,13 +4,14 @@ use crate::{
     sqlx_ext::{map_sqlx_error, DBTransaction, SqlBuilder},
 };
 use ::protobuf::ProtobufEnum;
-use flowy_net::{errors::ServerError, response::FlowyResponse};
-use flowy_workspace::protobuf::{CreateTrashParams, RepeatedTrash, Trash, TrashIdentifiers, TrashType};
+use flowy_net::errors::ServerError;
+use flowy_workspace::protobuf::{RepeatedTrash, Trash, TrashIdentifiers, TrashType};
 use sqlx::{postgres::PgArguments, Postgres};
+use uuid::Uuid;
 
 pub(crate) async fn create_trash(
     transaction: &mut DBTransaction<'_>,
-    trash_id: &str,
+    trash_id: Uuid,
     ty: i32,
     user: LoggedUser,
 ) -> Result<(), ServerError> {
@@ -28,10 +29,7 @@ pub(crate) async fn create_trash(
     Ok(())
 }
 
-pub(crate) async fn delete_trash(
-    transaction: &mut DBTransaction<'_>,
-    trash_ids: Vec<String>,
-) -> Result<(), ServerError> {
+pub(crate) async fn delete_trash(transaction: &mut DBTransaction<'_>, trash_ids: Vec<Uuid>) -> Result<(), ServerError> {
     for trash_id in trash_ids {
         let (sql, args) = SqlBuilder::delete(TRASH_TABLE).and_where_eq("id", &trash_id).build()?;
         let _ = sqlx::query_with(&sql, args)
@@ -43,15 +41,21 @@ pub(crate) async fn delete_trash(
 }
 
 pub(crate) async fn read_trash_ids(
-    _user: &LoggedUser,
-    _transaction: &mut DBTransaction<'_>,
+    user: &LoggedUser,
+    transaction: &mut DBTransaction<'_>,
 ) -> Result<Vec<String>, ServerError> {
-    Ok(vec![])
+    let repeated_trash = read_trash(transaction, user).await?.take_items().into_vec();
+    let ids = repeated_trash
+        .into_iter()
+        .map(|trash| trash.id)
+        .collect::<Vec<String>>();
+
+    Ok(ids)
 }
 
 pub(crate) async fn read_trash(
     transaction: &mut DBTransaction<'_>,
-    user: LoggedUser,
+    user: &LoggedUser,
 ) -> Result<RepeatedTrash, ServerError> {
     let (sql, args) = SqlBuilder::select(TRASH_TABLE)
         .add_field("*")

backend/src/service/view/router.rs

@@ -15,7 +15,7 @@ use flowy_net::{
 };
 use flowy_workspace::{
     entities::view::parser::{ViewDesc, ViewName, ViewThumbnail},
-    protobuf::{CreateViewParams, DeleteViewParams, QueryViewParams, UpdateViewParams},
+    protobuf::{CreateViewParams, DeleteViewParams, UpdateViewParams, ViewIdentifier},
 };
 use sqlx::PgPool;
 use std::sync::Arc;
@@ -42,7 +42,7 @@ pub async fn create_handler(
 }
 
 pub async fn read_handler(payload: Payload, pool: Data<PgPool>, user: LoggedUser) -> Result<HttpResponse, ServerError> {
-    let params: QueryViewParams = parse_from_payload(payload).await?;
+    let params: ViewIdentifier = parse_from_payload(payload).await?;
     let view_id = check_view_ids(vec![params.view_id])?.pop().unwrap();
     let mut transaction = pool
         .begin()

backend/src/service/view/view.rs

@@ -92,6 +92,12 @@ pub(crate) async fn read_view(
     transaction: &mut DBTransaction<'_>,
 ) -> Result<View, ServerError> {
     let table = read_view_table(view_id, transaction as &mut DBTransaction<'_>).await?;
+
+    let read_trash_ids = read_trash_ids(user, transaction).await?;
+    if read_trash_ids.contains(&table.id.to_string()) {
+        return Err(ServerError::record_not_found());
+    }
+
     let mut views = RepeatedView::default();
     views.set_items(
         read_view_belong_to_id(&user, transaction, &table.id.to_string())

backend/tests/api/workspace.rs

@@ -1,7 +1,8 @@
 use crate::helper::*;
 use flowy_workspace::entities::{
     app::{AppIdentifier, DeleteAppParams, UpdateAppParams},
-    view::UpdateViewParams,
+    trash::{CreateTrashParams, TrashType},
+    view::{UpdateViewParams, ViewIdentifier},
     workspace::{CreateWorkspaceParams, DeleteWorkspaceParams, QueryWorkspaceParams, UpdateWorkspaceParams},
 };
 
@@ -97,9 +98,11 @@ async fn app_read_with_belongs_in_trash() {
     let _ = create_test_view(&test.server, &test.app.id).await;
     let view = create_test_view(&test.server, &test.app.id).await;
 
-    let update_params = UpdateViewParams::new(&view.id).trash();
-    // create trash
-    test.server.update_view(update_params).await;
+    let params = CreateTrashParams {
+        id: view.id.clone(),
+        ty: TrashType::View,
+    };
+    test.server.create_trash(params).await;
 
     let read_params = AppIdentifier::new(&test.app.id);
     let app = test.server.read_app(read_params).await.unwrap();
@@ -138,35 +141,36 @@ async fn view_create() {
     log::info!("{:?}", test.view);
 }
 
-// #[actix_rt::test]
-// async fn view_update() {
-//     let test = ViewTest::new().await;
-//     let new_name = "name view name";
-//
-//     // update
-//     let update_params =
-// UpdateViewParams::new(&test.view.id).trash().name(new_name);     test.server.
-// update_view(update_params).await;
-//
-//     // read
-//     let read_params = QueryViewParams::new(&test.view.id).trash();
-//     let view = test.server.read_view(read_params).await.unwrap();
-//     assert_eq!(&view.name, new_name);
-// }
+#[actix_rt::test]
+async fn view_update() {
+    let test = ViewTest::new().await;
+    let new_name = "name view name";
 
-// #[actix_rt::test]
-// async fn view_delete() {
-//     let test = ViewTest::new().await;
-//     // delete
-//     let delete_params = DeleteViewParams {
-//         view_ids: vec![test.view.id.clone()],
-//     };
-//     test.server.delete_view(delete_params).await;
-//
-//     // read
-//     let read_params = QueryViewParams::new(&test.view.id).trash();
-//     assert_eq!(test.server.read_view(read_params).await.is_none(), true);
-// }
+    // update
+    let update_params = UpdateViewParams::new(&test.view.id).name(new_name);
+    test.server.update_view(update_params).await;
+
+    // read
+    let read_params = ViewIdentifier::new(&test.view.id);
+    let view = test.server.read_view(read_params).await.unwrap();
+    assert_eq!(&view.name, new_name);
+}
+
+#[actix_rt::test]
+async fn view_delete() {
+    let test = ViewTest::new().await;
+
+    // delete
+    let params = CreateTrashParams {
+        id: test.view.id.clone(),
+        ty: TrashType::View,
+    };
+    test.server.create_trash(params).await;
+
+    // read
+    let read_params = ViewIdentifier::new(&test.view.id);
+    assert_eq!(test.server.read_view(read_params).await.is_none(), true);
+}
 
 #[actix_rt::test]
 async fn workspace_list_read() {

backend/tests/helper.rs

@@ -106,7 +106,7 @@ impl TestUserServer {
         view
     }
 
-    pub async fn read_view(&self, params: QueryViewParams) -> Option<View> {
+    pub async fn read_view(&self, params: ViewIdentifier) -> Option<View> {
         let url = format!("{}/api/view", self.http_addr());
         let view = read_view_request(self.user_token(), params, &url).await.unwrap();
         view