chk
/
AppFlowy-Cloud
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: add create, retrieve, delete API for publish view global comment

This commit is contained in:
Khor Shu Heng 2024-07-23 16:02:52 +08:00
parent 47f87cee1c
commit 6eea93d774
7 changed files with 304 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
.sqlx/query-33ca377a92ff965e348f23fae86a532d2b2576f5f4066d08455634b05cf380c7.json Normal file
View File

@ -0,0 +1,23 @@
{
"db_name": "PostgreSQL",
"query": "\n SELECT EXISTS(\n SELECT true\n FROM af_published_collab\n WHERE view_id = $1\n AND published_by = (SELECT uid FROM af_user WHERE uuid = $2)\n ) AS \"exists\";\n ",
"describe": {
"columns": [
{
"ordinal": 0,
"name": "exists",
"type_info": "Bool"
}
],
"parameters": {
"Left": [
"Uuid",
"Uuid"
]
},
"nullable": [
null
]
},
"hash": "33ca377a92ff965e348f23fae86a532d2b2576f5f4066d08455634b05cf380c7"
}

60
libs/client-api/src/http_publish.rs
View File

@ -1,5 +1,8 @@
use bytes::Bytes;
use client_api_entity::{PublishInfo, UpdatePublishNamespace};
use client_api_entity::{
CreateGlobalCommentParams, DeleteGlobalCommentParams, GlobalComments, PublishInfo,
UpdatePublishNamespace,
};
use reqwest::Method;
use shared_entity::response::{AppResponse, AppResponseError};
use tracing::instrument;
@ -62,6 +65,47 @@ impl Client {
.await?;
AppResponse::<()>::from_response(resp).await?.into_error()
}
pub async fn create_comment_on_published_view(
&self,
view_id: &uuid::Uuid,
comment_content: &str,
) -> Result<(), AppResponseError> {
let url = format!(
"{}/api/workspace/published-info/{}/comment",
self.base_url, view_id
);
let resp = self
.http_client_with_auth(Method::POST, &url)
.await?
.json(&CreateGlobalCommentParams {
content: comment_content.to_string(),
reply_comment_id: None,
})
.send()
.await?;
AppResponse::<()>::from_response(resp).await?.into_error()
}
pub async fn delete_comment_on_published_view(
&self,
view_id: &uuid::Uuid,
comment_id: &uuid::Uuid,
) -> Result<(), AppResponseError> {
let url = format!(
"{}/api/workspace/published-info/{}/comment",
self.base_url, view_id
);
let resp = self
.http_client_with_auth(Method::DELETE, &url)
.await?
.json(&DeleteGlobalCommentParams {
comment_id: *comment_id,
})
.send()
.await?;
AppResponse::<()>::from_response(resp).await?.into_error()
}
}
// Guest API (no login required)
@ -146,4 +190,18 @@ impl Client {
Ok(bytes)
}
pub async fn get_published_view_comments(
&self,
view_id: &uuid::Uuid,
) -> Result<GlobalComments, AppResponseError> {
let url = format!(
"{}/api/workspace/published-info/{}/comment",
self.base_url, view_id
);
let resp = self.cloud_client.get(&url).send().await?;
AppResponse::<GlobalComments>::from_response(resp)
.await?
.into_data()
}
}

25
libs/database-entity/src/dto.rs
View File

@ -846,6 +846,31 @@ pub struct PublishCollabItem<Meta, Data> {
pub data: Data,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct GlobalComments(pub Vec<GlobalComment>);
#[derive(Serialize, Deserialize, Debug)]
pub struct GlobalComment {
pub user: Option<AFWorkspaceMember>,
pub created_at: DateTime<Utc>,
pub last_updated_at: DateTime<Utc>,
pub content: String,
pub reply_comment_id: Option<Uuid>,
pub comment_id: Uuid,
pub is_deleted: bool,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct CreateGlobalCommentParams {
pub content: String,
pub reply_comment_id: Option<Uuid>,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct DeleteGlobalCommentParams {
pub comment_id: Uuid,
}
/// Indexing status of a document.
#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum IndexingStatus {

23
libs/database/src/workspace.rs
View File

@ -171,6 +171,29 @@ pub async fn select_user_is_collab_publisher_for_all_views(
}
}
pub async fn select_user_is_collab_publisher_for_view(
pg_pool: &PgPool,
user_uuid: &Uuid,
view_id: &Uuid,
) -> Result<bool, AppError> {
let is_publisher_for_view = sqlx::query_scalar!(
r#"
SELECT EXISTS(
SELECT true
FROM af_published_collab
WHERE view_id = $1
AND published_by = (SELECT uid FROM af_user WHERE uuid = $2)
) AS "exists";
"#,
view_id,
user_uuid,
)
.fetch_one(pg_pool)
.await?;
Ok(is_publisher_for_view.unwrap_or(false))
}
#[inline]
pub async fn select_user_role<'a, E: Executor<'a, Database = Postgres>>(
exectuor: E,

49
src/api/workspace.rs
View File

@ -1,4 +1,8 @@
use crate::api::util::PayloadReader;
use crate::biz::workspace::ops::{
create_comment_on_published_view, delete_comment_on_published_view,
get_comments_on_published_view,
};
use actix_web::web::{Bytes, Payload};
use actix_web::web::{Data, Json, PayloadConfig};
use actix_web::{web, Scope};
@ -143,6 +147,12 @@ pub fn workspace_scope() -> Scope {
web::resource("/published-info/{view_id}")
.route(web::get().to(get_published_collab_info_handler))
)
.service(
web::resource("/published-info/{view_id}/comment")
.route(web::get().to(get_published_collab_comment_handler))
.route(web::post().to(post_published_collab_comment_handler))
.route(web::delete().to(delete_published_collab_comment_handler))
)
.service(
web::resource("/{workspace_id}/publish-namespace")
.route(web::put().to(put_publish_namespace_handler))
@ -1087,6 +1097,45 @@ async fn get_published_collab_info_handler(
Ok(Json(AppResponse::Ok().with_data(collab_data)))
}
async fn get_published_collab_comment_handler(
view_id: web::Path<Uuid>,
state: Data<AppState>,
) -> Result<JsonAppResponse<GlobalComments>> {
let view_id = view_id.into_inner();
let comments = get_comments_on_published_view(&state.pg_pool, &view_id).await?;
let resp = GlobalComments(comments);
Ok(Json(AppResponse::Ok().with_data(resp)))
}
async fn post_published_collab_comment_handler(
user_uuid: UserUuid,
view_id: web::Path<Uuid>,
state: Data<AppState>,
data: Json<CreateGlobalCommentParams>,
) -> Result<JsonAppResponse<()>> {
let view_id = view_id.into_inner();
create_comment_on_published_view(
&state.pg_pool,
&view_id,
&data.reply_comment_id,
&data.content,
&user_uuid,
)
.await?;
Ok(Json(AppResponse::Ok()))
}
async fn delete_published_collab_comment_handler(
user_uuid: UserUuid,
view_id: web::Path<Uuid>,
state: Data<AppState>,
data: Json<DeleteGlobalCommentParams>,
) -> Result<JsonAppResponse<()>> {
let view_id = view_id.into_inner();
delete_comment_on_published_view(&state.pg_pool, &view_id, &data.comment_id, &user_uuid).await?;
Ok(Json(AppResponse::Ok()))
}
async fn post_publish_collabs_handler(
workspace_id: web::Path<Uuid>,
user_uuid: UserUuid,

52
src/biz/workspace/ops.rs
View File

@ -23,16 +23,17 @@ use database::workspace::{
get_invitation_by_id, insert_or_replace_publish_collab_metas, insert_user_workspace,
insert_workspace_invitation, rename_workspace, select_all_user_workspaces,
select_publish_collab_meta, select_published_collab_blob, select_published_collab_info,
select_user_is_collab_publisher_for_all_views, select_user_is_workspace_owner, select_workspace,
select_workspace_invitations_for_user, select_workspace_member, select_workspace_member_list,
select_workspace_publish_namespace, select_workspace_publish_namespace_exists,
select_workspace_settings, select_workspace_total_collab_bytes, update_updated_at_of_workspace,
select_user_is_collab_publisher_for_all_views, select_user_is_collab_publisher_for_view,
select_user_is_workspace_owner, select_workspace, select_workspace_invitations_for_user,
select_workspace_member, select_workspace_member_list, select_workspace_publish_namespace,
select_workspace_publish_namespace_exists, select_workspace_settings,
select_workspace_total_collab_bytes, update_updated_at_of_workspace,
update_workspace_invitation_set_status_accepted, update_workspace_publish_namespace,
upsert_workspace_member, upsert_workspace_member_with_txn, upsert_workspace_settings,
};
use database_entity::dto::{
AFAccessLevel, AFRole, AFWorkspace, AFWorkspaceInvitation, AFWorkspaceInvitationStatus,
AFWorkspaceSettings, WorkspaceUsage,
AFWorkspaceSettings, GlobalComment, WorkspaceUsage,
};
use gotrue::params::{GenerateLinkParams, GenerateLinkType};
use shared_entity::dto::workspace_dto::{
@ -173,6 +174,33 @@ pub async fn get_published_collab_info(
select_published_collab_info(pg_pool, view_id).await
}
pub async fn get_comments_on_published_view(
_pg_pool: &PgPool,
_view_id: &Uuid,
) -> Result<Vec<GlobalComment>, AppError> {
Ok(vec![])
}
pub async fn create_comment_on_published_view(
_pg_pool: &PgPool,
_view_id: &Uuid,
_replay_comment_id: &Option<Uuid>,
_content: &str,
_user_uuid: &Uuid,
) -> Result<(), AppError> {
Ok(())
}
pub async fn delete_comment_on_published_view(
pg_pool: &PgPool,
view_id: &Uuid,
_comment_id: &Uuid,
user_uuid: &Uuid,
) -> Result<(), AppError> {
check_if_user_is_publisher(pg_pool, user_uuid, view_id).await?;
Ok(())
}
pub async fn delete_published_workspace_collab(
pg_pool: &PgPool,
workspace_id: &Uuid,
@ -601,6 +629,20 @@ async fn check_workspace_owner_or_publisher(
Ok(())
}
async fn check_if_user_is_publisher(
pg_pool: &PgPool,
user_uuid: &Uuid,
view_id: &Uuid,
) -> Result<(), AppError> {
let is_publisher = select_user_is_collab_publisher_for_view(pg_pool, user_uuid, view_id).await?;
if !is_publisher {
return Err(AppError::UserUnAuthorized(
"User is not the publisher of the document".to_string(),
));
}
Ok(())
}
fn check_collab_publish_name(publish_name: &str) -> Result<(), AppError> {
// Check len
if publish_name.len() > 128 {

79
tests/workspace/publish.rs
View File

@ -1,6 +1,8 @@
use client_api::entity::{AFRole, PublishCollabItem, PublishCollabMetadata};
use app_error::ErrorCode;
use client_api::entity::{AFRole, GlobalComment, PublishCollabItem, PublishCollabMetadata};
use client_api_test::TestClient;
use client_api_test::{generate_unique_registered_user_client, localhost_client};
use uuid::Uuid;
#[tokio::test]
async fn test_set_publish_namespace_set() {
@ -211,6 +213,81 @@ async fn test_publish_doc() {
}
}
#[tokio::test]
async fn test_publish_comments() {
let (page_owner_client, _) = generate_unique_registered_user_client().await;
let workspace_id = get_first_workspace_string(&page_owner_client).await;
let published_view_namespace = uuid::Uuid::new_v4().to_string();
page_owner_client
.set_workspace_publish_namespace(&workspace_id.to_string(), &published_view_namespace)
.await
.unwrap();
let publish_name = "published-view";
let view_id = uuid::Uuid::new_v4();
page_owner_client
.publish_collabs::<MyCustomMetadata, &[u8]>(
&workspace_id,
vec![PublishCollabItem {
meta: PublishCollabMetadata {
view_id,
publish_name: publish_name.to_string(),
metadata: MyCustomMetadata {
title: "some_title".to_string(),
},
},
data: "yrs_encoded_data_1".as_bytes(),
}],
)
.await
.unwrap();
// TODO: replace the placeholder with actual comment id once the API implementation is completed
let place_holder_comment_id = Uuid::new_v4();
let published_view_comments: Vec<GlobalComment> = page_owner_client
.get_published_view_comments(&view_id)
.await
.unwrap()
.0;
assert_eq!(published_view_comments.len(), 0);
page_owner_client
.create_comment_on_published_view(&view_id, "comment from page owner")
.await
.unwrap();
page_owner_client
.delete_comment_on_published_view(&view_id, &place_holder_comment_id)
.await
.unwrap();
let guest_client = localhost_client();
let published_view_comments: Vec<GlobalComment> = guest_client
.get_published_view_comments(&view_id)
.await
.unwrap()
.0;
assert_eq!(published_view_comments.len(), 0);
let guest_client = localhost_client();
let result = guest_client
.create_comment_on_published_view(&view_id, "comment from anonymous")
.await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code, ErrorCode::NotLoggedIn);
let result = guest_client
.delete_comment_on_published_view(&view_id, &place_holder_comment_id)
.await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code, ErrorCode::NotLoggedIn);
let (authenticated_user_client, _) = generate_unique_registered_user_client().await;
authenticated_user_client
.create_comment_on_published_view(&view_id, "comment from authenticated user")
.await
.unwrap();
let result = authenticated_user_client
.delete_comment_on_published_view(&view_id, &place_holder_comment_id)
.await;
assert!(result.is_err());
assert_eq!(result.unwrap_err().code, ErrorCode::UserUnAuthorized)
}
#[tokio::test]
async fn test_publish_load_test() {
let (c, _user) = generate_unique_registered_user_client().await;