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

Merge pull request #1012 from AppFlowy-IO/feat/search-database-by-name 

Feat/search database by name
This commit is contained in:
Zack 2024-11-21 19:21:51 -08:00 committed by GitHub
parent 1e18180e9d 687b5d9f6d
commit 3a0b210d48
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 102 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libs/client-api/src/http_collab.rs
View File

@ -2,7 +2,7 @@ use crate::http::log_request_id;
use crate::{blocking_brotli_compress, brotli_compress, Client};
use app_error::AppError;
use bytes::Bytes;
use client_api_entity::workspace_dto::AFDatabase;
use client_api_entity::workspace_dto::{AFDatabase, ListDatabaseParam};
use client_api_entity::{
BatchQueryCollabParams, BatchQueryCollabResult, CollabParams, CreateCollabParams,
DeleteCollabParams, PublishCollabItem, QueryCollab, QueryCollabParams, UpdateCollabWebParams,
@ -159,11 +159,13 @@ impl Client {
pub async fn list_databases(
&self,
workspace_id: &str,
name_filter: Option<String>,
) -> Result<Vec<AFDatabase>, AppResponseError> {
let url = format!("{}/api/workspace/{}/database", self.base_url, workspace_id);
let resp = self
.http_client_with_auth(Method::GET, &url)
.await?
.query(&ListDatabaseParam { name_filter })
.send()
.await?;
log_request_id(&resp);

13
libs/shared-entity/src/dto/workspace_dto.rs
View File

@ -293,6 +293,11 @@ pub struct QueryWorkspaceParam {
pub include_role: Option<bool>,
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct ListDatabaseParam {
pub name_filter: Option<String>, // logic: if database name contains
}
#[derive(Default, Debug, Deserialize, Serialize)]
pub struct QueryWorkspaceFolder {
pub depth: Option<u32>,
@ -314,7 +319,7 @@ pub struct PublishedView {
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct AFDatabase {
pub id: String,
pub name: String,
pub names: Vec<String>,
pub fields: Vec<AFDatabaseField>,
}
@ -323,3 +328,9 @@ pub struct AFDatabaseField {
pub name: String,
pub field_type: String,
}
#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct AFDatabaseMeta {
pub name: String,
pub icon: String,
}

3
src/api/workspace.rs
View File

@ -1858,7 +1858,9 @@ async fn list_database_handler(
user_uuid: UserUuid,
workspace_id: web::Path<String>,
state: Data<AppState>,
query: web::Query<ListDatabaseParam>,
) -> Result<Json<AppResponse<Vec<AFDatabase>>>> {
let name_filter = query.into_inner().name_filter;
let uid = state.user_cache.get_user_uid(&user_uuid).await?;
let workspace_id = workspace_id.into_inner();
let dbs = biz::collab::ops::list_database(
@ -1866,6 +1868,7 @@ async fn list_database_handler(
&state.collab_access_control_storage,
uid,
workspace_id,
name_filter,
)
.await?;
Ok(Json(AppResponse::Ok().with_data(dbs)))

50
src/biz/collab/ops.rs
View File

@ -363,6 +363,7 @@ pub async fn list_database(
collab_storage: &CollabAccessControlStorage,
uid: i64,
workspace_uuid_str: String,
name_filter: Option<String>,
) -> Result<Vec<AFDatabase>, AppError> {
let workspace_uuid: Uuid = workspace_uuid_str.as_str().parse()?;
let ws_db_oid = select_workspace_database_oid(pg_pool, &workspace_uuid).await?;
@ -416,28 +417,35 @@ pub async fn list_database(
Arc::new(NoPersistenceDatabaseCollabService),
None,
) {
Some(db_body) => match db_body.metas.get_inline_view_id(&txn) {
Some(iid) => match db_body.views.get_view(&txn, &iid) {
Some(iview) => {
let name = iview.name;
Some(db_body) => {
let db_views = db_body.views.get_all_views_meta(&txn);
let names = db_views
.iter()
.map(|v| v.name.clone())
.filter(|name| !name.is_empty())
.collect::<Vec<String>>();
let db_fields = db_body.fields.get_all_fields(&txn);
let mut af_fields: Vec<AFDatabaseField> = Vec::with_capacity(db_fields.len());
for db_field in db_fields {
af_fields.push(AFDatabaseField {
name: db_field.name,
field_type: format!("{:?}", FieldType::from(db_field.field_type)),
});
}
af_databases.push(AFDatabase {
id: db_body.get_database_id(&txn),
name,
fields: af_fields,
});
},
None => tracing::warn!("Failed to get inline view: {}", iid),
},
None => tracing::error!("Failed to get inline view id for database: {}", oid),
// if there exists a name filter,
// there must be at least one view name that contains the filter
if let Some(name_filter) = &name_filter {
if !names.iter().any(|name| name.contains(name_filter)) {
continue;
}
}
let db_fields = db_body.fields.get_all_fields(&txn);
let mut af_fields: Vec<AFDatabaseField> = Vec::with_capacity(db_fields.len());
for db_field in db_fields {
af_fields.push(AFDatabaseField {
name: db_field.name,
field_type: format!("{:?}", FieldType::from(db_field.field_type)),
});
}
af_databases.push(AFDatabase {
id: db_body.get_database_id(&txn),
names,
fields: af_fields,
});
},
None => tracing::error!("Failed to create db_body from db_collab, oid: {}", oid),
},

80
tests/workspace/workspace_crud.rs
View File

@ -8,33 +8,63 @@ use shared_entity::dto::workspace_dto::PatchWorkspaceParam;
#[tokio::test]
async fn workspace_list_database() {
let (c, _user) = generate_unique_registered_user_client().await;
let workspace_id = c.get_workspaces().await.unwrap()[0].workspace_id;
let dbs = c.list_databases(&workspace_id.to_string()).await.unwrap();
assert_eq!(dbs.len(), 1);
let workspace_id = c.get_workspaces().await.unwrap()[0]
.workspace_id
.to_string();
let db = &dbs[0];
{
let dbs = c.list_databases(&workspace_id, None).await.unwrap();
assert_eq!(dbs.len(), 1);
assert_eq!(db.name, "");
assert!(db.fields.contains(&AFDatabaseField {
name: "Last modified".to_string(),
field_type: "LastEditedTime".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Multiselect".to_string(),
field_type: "MultiSelect".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Tasks".to_string(),
field_type: "Checklist".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Status".to_string(),
field_type: "SingleSelect".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Description".to_string(),
field_type: "RichText".to_string(),
}));
let db = &dbs[0];
assert_eq!(db.names.len(), 2);
assert!(db.names.contains(&String::from("Untitled")));
assert!(db.names.contains(&String::from("Grid")));
assert!(db.fields.contains(&AFDatabaseField {
name: "Last modified".to_string(),
field_type: "LastEditedTime".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Multiselect".to_string(),
field_type: "MultiSelect".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Tasks".to_string(),
field_type: "Checklist".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Status".to_string(),
field_type: "SingleSelect".to_string(),
}));
assert!(db.fields.contains(&AFDatabaseField {
name: "Description".to_string(),
field_type: "RichText".to_string(),
}));
}
{
let dbs = c
.list_databases(&workspace_id, Some(String::from("nomatch")))
.await
.unwrap();
assert_eq!(dbs.len(), 0);
}
{
let dbs = c
.list_databases(&workspace_id, Some(String::from("ntitle")))
.await
.unwrap();
assert_eq!(dbs.len(), 1);
}
{
let dbs = c
.list_databases(&workspace_id, Some(String::from("rid")))
.await
.unwrap();
assert_eq!(dbs.len(), 1);
}
}
#[tokio::test]