Mirrored_Repos/AppFlowy
1
0
Fork 0
mirror of https://github.com/AppFlowy-IO/AppFlowy.git synced 2024-08-30 18:12:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: rename struct property

Browse Source
This commit is contained in:
appflowy
2022-02-24 21:49:18 +08:00
parent 93695dc4be
commit ed9a48fc1c
65 changed files with 965 additions and 1512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
frontend/rust-lib/flowy-folder/src/event_map.rs
View File

@ -82,43 +82,43 @@ pub fn create(folder: Arc<FolderManager>) -> Module {
#[derive(Clone, Copy, PartialEq, Eq, Debug, Display, Hash, ProtoBuf_Enum, Flowy_Event)]
#[event_err = "FlowyError"]
pub enum FolderEvent {
#[event(input = "CreateWorkspaceRequest", output = "Workspace")]
#[event(input = "CreateWorkspacePayload", output = "Workspace")]
CreateWorkspace = 0,
#[event(output = "CurrentWorkspaceSetting")]
ReadCurWorkspace = 1,
#[event(input = "QueryWorkspaceRequest", output = "RepeatedWorkspace")]
#[event(input = "WorkspaceId", output = "RepeatedWorkspace")]
ReadWorkspaces = 2,
#[event(input = "QueryWorkspaceRequest")]
#[event(input = "WorkspaceId")]
DeleteWorkspace = 3,
#[event(input = "QueryWorkspaceRequest", output = "Workspace")]
#[event(input = "WorkspaceId", output = "Workspace")]
OpenWorkspace = 4,
#[event(input = "QueryWorkspaceRequest", output = "RepeatedApp")]
#[event(input = "WorkspaceId", output = "RepeatedApp")]
ReadWorkspaceApps = 5,
#[event(input = "CreateAppRequest", output = "App")]
#[event(input = "CreateAppPayload", output = "App")]
CreateApp = 101,
#[event(input = "QueryAppRequest")]
#[event(input = "AppId")]
DeleteApp = 102,
#[event(input = "QueryAppRequest", output = "App")]
#[event(input = "AppId", output = "App")]
ReadApp = 103,
#[event(input = "UpdateAppRequest")]
#[event(input = "UpdateAppPayload")]
UpdateApp = 104,
#[event(input = "CreateViewRequest", output = "View")]
#[event(input = "CreateViewPayload", output = "View")]
CreateView = 201,
#[event(input = "ViewId", output = "View")]
ReadView = 202,
#[event(input = "UpdateViewRequest", output = "View")]
#[event(input = "UpdateViewPayload", output = "View")]
UpdateView = 203,
#[event(input = "RepeatedViewId")]
@ -154,7 +154,7 @@ pub enum FolderEvent {
#[event(input = "DocumentDelta", output = "DocumentDelta")]
ApplyDocDelta = 400,
#[event(input = "ExportRequest", output = "ExportData")]
#[event(input = "ExportPayload", output = "ExportData")]
ExportDocument = 500,
}

2
frontend/rust-lib/flowy-folder/src/services/app/controller.rs
View File

@ -64,7 +64,7 @@ impl AppController {
let app = self
.persistence
.begin_transaction(|transaction| {
let app = transaction.read_app(&params.app_id)?;
let app = transaction.read_app(&params.value)?;
let trash_ids = self.trash_controller.read_trash_ids(&transaction)?;
if trash_ids.contains(&app.id) {
return Err(FlowyError::record_not_found());

18
frontend/rust-lib/flowy-folder/src/services/app/event_handler.rs
View File

@ -1,6 +1,6 @@
use crate::{
entities::{
app::{App, AppId, CreateAppParams, CreateAppRequest, QueryAppRequest, UpdateAppParams, UpdateAppRequest},
app::{App, AppId, CreateAppParams, CreateAppPayload, UpdateAppParams, UpdateAppPayload},
trash::Trash,
},
errors::FlowyError,
@ -10,7 +10,7 @@ use lib_dispatch::prelude::{data_result, Data, DataResult, Unit};
use std::{convert::TryInto, sync::Arc};
pub(crate) async fn create_app_handler(
data: Data<CreateAppRequest>,
data: Data<CreateAppPayload>,
controller: Unit<Arc<AppController>>,
) -> DataResult<App, FlowyError> {
let params: CreateAppParams = data.into_inner().try_into()?;
@ -20,13 +20,13 @@ pub(crate) async fn create_app_handler(
}
pub(crate) async fn delete_app_handler(
data: Data<QueryAppRequest>,
data: Data<AppId>,
app_controller: Unit<Arc<AppController>>,
trash_controller: Unit<Arc<TrashController>>,
) -> Result<(), FlowyError> {
let params: AppId = data.into_inner().try_into()?;
let params: AppId = data.into_inner();
let trash = app_controller
.read_local_apps(vec![params.app_id])
.read_local_apps(vec![params.value])
.await?
.into_iter()
.map(|app| app.into())
@ -38,7 +38,7 @@ pub(crate) async fn delete_app_handler(
#[tracing::instrument(skip(data, controller))]
pub(crate) async fn update_app_handler(
data: Data<UpdateAppRequest>,
data: Data<UpdateAppPayload>,
controller: Unit<Arc<AppController>>,
) -> Result<(), FlowyError> {
let params: UpdateAppParams = data.into_inner().try_into()?;
@ -48,13 +48,13 @@ pub(crate) async fn update_app_handler(
#[tracing::instrument(skip(data, app_controller, view_controller))]
pub(crate) async fn read_app_handler(
data: Data<QueryAppRequest>,
data: Data<AppId>,
app_controller: Unit<Arc<AppController>>,
view_controller: Unit<Arc<ViewController>>,
) -> DataResult<App, FlowyError> {
let params: AppId = data.into_inner().try_into()?;
let params: AppId = data.into_inner();
let mut app = app_controller.read_app(params.clone()).await?;
app.belongings = view_controller.read_views_belong_to(&params.app_id).await?;
app.belongings = view_controller.read_views_belong_to(&params.value).await?;
data_result(app)
}

14
frontend/rust-lib/flowy-folder/src/services/view/controller.rs
View File

@ -113,12 +113,12 @@ impl ViewController {
.await
}
#[tracing::instrument(skip(self, params), fields(view_id = %params.view_id), err)]
pub(crate) async fn read_view(&self, params: ViewId) -> Result<View, FlowyError> {
#[tracing::instrument(skip(self, view_id), fields(view_id = %view_id.value), err)]
pub(crate) async fn read_view(&self, view_id: ViewId) -> Result<View, FlowyError> {
let view = self
.persistence
.begin_transaction(|transaction| {
let view = transaction.read_view(&params.view_id)?;
let view = transaction.read_view(&view_id.value)?;
let trash_ids = self.trash_controller.read_trash_ids(&transaction)?;
if trash_ids.contains(&view.id) {
return Err(FlowyError::record_not_found());
@ -126,7 +126,7 @@ impl ViewController {
Ok(view)
})
.await?;
let _ = self.read_view_on_server(params);
let _ = self.read_view_on_server(view_id);
Ok(view)
}
@ -159,14 +159,14 @@ impl ViewController {
Ok(())
}
#[tracing::instrument(level = "debug", skip(self,params), fields(doc_id = %params.doc_id), err)]
#[tracing::instrument(level = "debug", skip(self,params), fields(doc_id = %params.value), err)]
pub(crate) async fn delete_view(&self, params: DocumentId) -> Result<(), FlowyError> {
if let Some(view_id) = KV::get_str(LATEST_VIEW_ID) {
if view_id == params.doc_id {
if view_id == params.value {
let _ = KV::remove(LATEST_VIEW_ID);
}
}
let _ = self.document_manager.close_document(&params.doc_id)?;
let _ = self.document_manager.close_document(&params.value)?;
Ok(())
}

28
frontend/rust-lib/flowy-folder/src/services/view/event_handler.rs
View File

@ -2,19 +2,19 @@ use crate::{
entities::{
trash::Trash,
view::{
CreateViewParams, CreateViewRequest, RepeatedViewId, UpdateViewParams, UpdateViewRequest, View, ViewId,
CreateViewParams, CreateViewPayload, RepeatedViewId, UpdateViewParams, UpdateViewPayload, View, ViewId,
},
},
errors::FlowyError,
services::{TrashController, ViewController},
};
use flowy_collaboration::entities::document_info::DocumentDelta;
use flowy_folder_data_model::entities::share::{ExportData, ExportParams, ExportRequest};
use flowy_folder_data_model::entities::share::{ExportData, ExportParams, ExportPayload};
use lib_dispatch::prelude::{data_result, Data, DataResult, Unit};
use std::{convert::TryInto, sync::Arc};
pub(crate) async fn create_view_handler(
data: Data<CreateViewRequest>,
data: Data<CreateViewPayload>,
controller: Unit<Arc<ViewController>>,
) -> DataResult<View, FlowyError> {
let params: CreateViewParams = data.into_inner().try_into()?;
@ -26,18 +26,18 @@ pub(crate) async fn read_view_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
) -> DataResult<View, FlowyError> {
let params: ViewId = data.into_inner();
let mut view = controller.read_view(params.clone()).await?;
let view_id: ViewId = data.into_inner();
let mut view = controller.read_view(view_id.clone()).await?;
// For the moment, app and view can contains lots of views. Reading the view
// belongings using the view_id.
view.belongings = controller.read_views_belong_to(&params.view_id).await?;
view.belongings = controller.read_views_belong_to(&view_id.value).await?;
data_result(view)
}
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn update_view_handler(
data: Data<UpdateViewRequest>,
data: Data<UpdateViewPayload>,
controller: Unit<Arc<ViewController>>,
) -> Result<(), FlowyError> {
let params: UpdateViewParams = data.into_inner().try_into()?;
@ -79,8 +79,8 @@ pub(crate) async fn open_document_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
) -> DataResult<DocumentDelta, FlowyError> {
let params: ViewId = data.into_inner();
let doc = controller.open_document(&params.view_id).await?;
let view_id: ViewId = data.into_inner();
let doc = controller.open_document(&view_id.value).await?;
data_result(doc)
}
@ -88,8 +88,8 @@ pub(crate) async fn close_view_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
) -> Result<(), FlowyError> {
let params: ViewId = data.into_inner();
let _ = controller.close_view(&params.view_id).await?;
let view_id: ViewId = data.into_inner();
let _ = controller.close_view(&view_id.value).await?;
Ok(())
}
@ -98,14 +98,14 @@ pub(crate) async fn duplicate_view_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
) -> Result<(), FlowyError> {
let params: ViewId = data.into_inner();
let _ = controller.duplicate_view(&params.view_id).await?;
let view_id: ViewId = data.into_inner();
let _ = controller.duplicate_view(&view_id.value).await?;
Ok(())
}
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn export_handler(
data: Data<ExportRequest>,
data: Data<ExportPayload>,
controller: Unit<Arc<ViewController>>,
) -> DataResult<ExportData, FlowyError> {
let params: ExportParams = data.into_inner().try_into()?;

4
frontend/rust-lib/flowy-folder/src/services/workspace/controller.rs
View File

@ -96,7 +96,7 @@ impl WorkspaceController {
pub(crate) async fn open_workspace(&self, params: WorkspaceId) -> Result<Workspace, FlowyError> {
let user_id = self.user.user_id()?;
if let Some(workspace_id) = params.workspace_id {
if let Some(workspace_id) = params.value {
let workspace = self
.persistence
.begin_transaction(|transaction| self.read_local_workspace(workspace_id, &user_id, &transaction))
@ -174,7 +174,7 @@ impl WorkspaceController {
#[tracing::instrument(level = "trace", skip(self), err)]
fn delete_workspace_on_server(&self, workspace_id: &str) -> Result<(), FlowyError> {
let params = WorkspaceId {
workspace_id: Some(workspace_id.to_string()),
value: Some(workspace_id.to_string()),
};
let (token, server) = (self.user.token()?, self.cloud_service.clone());
tokio::spawn(async move {

16
frontend/rust-lib/flowy-folder/src/services/workspace/event_handler.rs
View File

@ -7,7 +7,7 @@ use crate::{
use flowy_folder_data_model::entities::{
app::RepeatedApp,
view::View,
workspace::{CurrentWorkspaceSetting, QueryWorkspaceRequest, RepeatedWorkspace, WorkspaceId, *},
workspace::{CurrentWorkspaceSetting, RepeatedWorkspace, WorkspaceId, *},
};
use lib_dispatch::prelude::{data_result, Data, DataResult, Unit};
@ -15,7 +15,7 @@ use std::{convert::TryInto, sync::Arc};
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn create_workspace_handler(
data: Data<CreateWorkspaceRequest>,
data: Data<CreateWorkspacePayload>,
controller: Unit<Arc<WorkspaceController>>,
) -> DataResult<Workspace, FlowyError> {
let controller = controller.get_ref().clone();
@ -34,20 +34,20 @@ pub(crate) async fn read_workspace_apps_handler(
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn open_workspace_handler(
data: Data<QueryWorkspaceRequest>,
data: Data<WorkspaceId>,
controller: Unit<Arc<WorkspaceController>>,
) -> DataResult<Workspace, FlowyError> {
let params: WorkspaceId = data.into_inner().try_into()?;
let params: WorkspaceId = data.into_inner();
let workspaces = controller.open_workspace(params).await?;
data_result(workspaces)
}
#[tracing::instrument(skip(data, folder), err)]
pub(crate) async fn read_workspaces_handler(
data: Data<QueryWorkspaceRequest>,
data: Data<WorkspaceId>,
folder: Unit<Arc<FolderManager>>,
) -> DataResult<RepeatedWorkspace, FlowyError> {
let params: WorkspaceId = data.into_inner().try_into()?;
let params: WorkspaceId = data.into_inner();
let user_id = folder.user.user_id()?;
let workspace_controller = folder.workspace_controller.clone();
@ -56,7 +56,7 @@ pub(crate) async fn read_workspaces_handler(
.persistence
.begin_transaction(|transaction| {
let mut workspaces =
workspace_controller.read_local_workspaces(params.workspace_id.clone(), &user_id, &transaction)?;
workspace_controller.read_local_workspaces(params.value.clone(), &user_id, &transaction)?;
for workspace in workspaces.iter_mut() {
let apps =
read_local_workspace_apps(&workspace.id, trash_controller.clone(), &transaction)?.into_inner();
@ -76,7 +76,7 @@ pub async fn read_cur_workspace_handler(
let workspace_id = get_current_workspace()?;
let user_id = folder.user.user_id()?;
let params = WorkspaceId {
workspace_id: Some(workspace_id.clone()),
value: Some(workspace_id.clone()),
};
let workspace = folder

6
frontend/rust-lib/flowy-folder/tests/workspace/folder_test.rs
View File

@ -1,6 +1,6 @@
use crate::script::{invalid_workspace_name_test_case, FolderScript::*, FolderTest};
use flowy_collaboration::{client_document::default::initial_delta_string, entities::revision::RevisionState};
use flowy_folder::entities::workspace::CreateWorkspaceRequest;
use flowy_folder::entities::workspace::CreateWorkspacePayload;
use flowy_test::{event_builder::*, FlowySDKTest};
#[tokio::test]
@ -64,14 +64,14 @@ async fn workspace_create_with_apps() {
async fn workspace_create_with_invalid_name() {
for (name, code) in invalid_workspace_name_test_case() {
let sdk = FlowySDKTest::default();
let request = CreateWorkspaceRequest {
let request = CreateWorkspacePayload {
name,
desc: "".to_owned(),
};
assert_eq!(
FolderEventBuilder::new(sdk)
.event(flowy_folder::event_map::FolderEvent::CreateWorkspace)
.request(request)
.payload(request)
.async_send()
.await
.error()

61
frontend/rust-lib/flowy-folder/tests/workspace/helper.rs
View File

@ -1,23 +1,24 @@
use flowy_collaboration::entities::document_info::DocumentInfo;
use flowy_folder::event_map::FolderEvent::*;
use flowy_folder_data_model::entities::view::{RepeatedViewId, ViewId};
use flowy_folder_data_model::entities::workspace::WorkspaceId;
use flowy_folder_data_model::entities::{
app::{App, AppId, CreateAppRequest, QueryAppRequest, UpdateAppRequest},
app::{App, AppId, CreateAppPayload, UpdateAppPayload},
trash::{RepeatedTrash, TrashId, TrashType},
view::{CreateViewRequest, UpdateViewRequest, View, ViewType},
workspace::{CreateWorkspaceRequest, QueryWorkspaceRequest, RepeatedWorkspace, Workspace},
view::{CreateViewPayload, UpdateViewPayload, View, ViewType},
workspace::{CreateWorkspacePayload, RepeatedWorkspace, Workspace},
};
use flowy_test::{event_builder::*, FlowySDKTest};
pub async fn create_workspace(sdk: &FlowySDKTest, name: &str, desc: &str) -> Workspace {
let request = CreateWorkspaceRequest {
let request = CreateWorkspacePayload {
name: name.to_owned(),
desc: desc.to_owned(),
};
let workspace = FolderEventBuilder::new(sdk.clone())
.event(CreateWorkspace)
.request(request)
.payload(request)
.async_send()
.await
.parse::<Workspace>();
@ -25,16 +26,16 @@ pub async fn create_workspace(sdk: &FlowySDKTest, name: &str, desc: &str) -> Wor
}
pub async fn read_workspace(sdk: &FlowySDKTest, workspace_id: Option<String>) -> Vec<Workspace> {
let request = QueryWorkspaceRequest { workspace_id };
let request = WorkspaceId { value: workspace_id };
let repeated_workspace = FolderEventBuilder::new(sdk.clone())
.event(ReadWorkspaces)
.request(request.clone())
.payload(request.clone())
.async_send()
.await
.parse::<RepeatedWorkspace>();
let workspaces;
if let Some(workspace_id) = &request.workspace_id {
if let Some(workspace_id) = &request.value {
workspaces = repeated_workspace
.into_inner()
.into_iter()
@ -49,7 +50,7 @@ pub async fn read_workspace(sdk: &FlowySDKTest, workspace_id: Option<String>) ->
}
pub async fn create_app(sdk: &FlowySDKTest, workspace_id: &str, name: &str, desc: &str) -> App {
let create_app_request = CreateAppRequest {
let create_app_request = CreateAppPayload {
workspace_id: workspace_id.to_owned(),
name: name.to_string(),
desc: desc.to_string(),
@ -58,7 +59,7 @@ pub async fn create_app(sdk: &FlowySDKTest, workspace_id: &str, name: &str, desc
let app = FolderEventBuilder::new(sdk.clone())
.event(CreateApp)
.request(create_app_request)
.payload(create_app_request)
.async_send()
.await
.parse::<App>();
@ -66,13 +67,13 @@ pub async fn create_app(sdk: &FlowySDKTest, workspace_id: &str, name: &str, desc
}
pub async fn read_app(sdk: &FlowySDKTest, app_id: &str) -> App {
let request = QueryAppRequest {
app_ids: vec![app_id.to_owned()],
let request = AppId {
value: app_id.to_owned(),
};
let app = FolderEventBuilder::new(sdk.clone())
.event(ReadApp)
.request(request)
.payload(request)
.async_send()
.await
.parse::<App>();
@ -81,7 +82,7 @@ pub async fn read_app(sdk: &FlowySDKTest, app_id: &str) -> App {
}
pub async fn update_app(sdk: &FlowySDKTest, app_id: &str, name: Option<String>, desc: Option<String>) {
let request = UpdateAppRequest {
let request = UpdateAppPayload {
app_id: app_id.to_string(),
name,
desc,
@ -91,25 +92,25 @@ pub async fn update_app(sdk: &FlowySDKTest, app_id: &str, name: Option<String>,
FolderEventBuilder::new(sdk.clone())
.event(UpdateApp)
.request(request)
.payload(request)
.async_send()
.await;
}
pub async fn delete_app(sdk: &FlowySDKTest, app_id: &str) {
let request = AppId {
app_id: app_id.to_string(),
value: app_id.to_string(),
};
FolderEventBuilder::new(sdk.clone())
.event(DeleteApp)
.request(request)
.payload(request)
.async_send()
.await;
}
pub async fn create_view(sdk: &FlowySDKTest, app_id: &str, name: &str, desc: &str, view_type: ViewType) -> View {
let request = CreateViewRequest {
let request = CreateViewPayload {
belong_to_id: app_id.to_string(),
name: name.to_string(),
desc: desc.to_string(),
@ -118,7 +119,7 @@ pub async fn create_view(sdk: &FlowySDKTest, app_id: &str, name: &str, desc: &st
};
let view = FolderEventBuilder::new(sdk.clone())
.event(CreateView)
.request(request)
.payload(request)
.async_send()
.await
.parse::<View>();
@ -126,19 +127,17 @@ pub async fn create_view(sdk: &FlowySDKTest, app_id: &str, name: &str, desc: &st
}
pub async fn read_view(sdk: &FlowySDKTest, view_id: &str) -> View {
let request = ViewId {
view_id: view_id.to_string(),
};
let view_id: ViewId = view_id.into();
FolderEventBuilder::new(sdk.clone())
.event(ReadView)
.request(request)
.payload(view_id)
.async_send()
.await
.parse::<View>()
}
pub async fn update_view(sdk: &FlowySDKTest, view_id: &str, name: Option<String>, desc: Option<String>) {
let request = UpdateViewRequest {
let request = UpdateViewPayload {
view_id: view_id.to_string(),
name,
desc,
@ -146,7 +145,7 @@ pub async fn update_view(sdk: &FlowySDKTest, view_id: &str, name: Option<String>
};
FolderEventBuilder::new(sdk.clone())
.event(UpdateView)
.request(request)
.payload(request)
.async_send()
.await;
}
@ -155,18 +154,16 @@ pub async fn delete_view(sdk: &FlowySDKTest, view_ids: Vec<String>) {
let request = RepeatedViewId { items: view_ids };
FolderEventBuilder::new(sdk.clone())
.event(DeleteView)
.request(request)
.payload(request)
.async_send()
.await;
}
pub async fn open_document(sdk: &FlowySDKTest, view_id: &str) -> DocumentInfo {
let request = ViewId {
view_id: view_id.to_string(),
};
let view_id: ViewId = view_id.into();
FolderEventBuilder::new(sdk.clone())
.event(OpenView)
.request(request)
.payload(view_id)
.async_send()
.await
.parse::<DocumentInfo>()
@ -187,7 +184,7 @@ pub async fn restore_app_from_trash(sdk: &FlowySDKTest, app_id: &str) {
};
FolderEventBuilder::new(sdk.clone())
.event(PutbackTrash)
.request(id)
.payload(id)
.async_send()
.await;
}
@ -199,7 +196,7 @@ pub async fn restore_view_from_trash(sdk: &FlowySDKTest, view_id: &str) {
};
FolderEventBuilder::new(sdk.clone())
.event(PutbackTrash)
.request(id)
.payload(id)
.async_send()
.await;
}