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

refactor: rename structs

Browse Source
This commit is contained in:
appflowy
2022-02-25 22:27:44 +08:00
parent 441627783b
commit 6078e46d3d
50 changed files with 707 additions and 699 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,7 +6,7 @@ use flowy_sync::RevisionWebSocket;
use lazy_static::lazy_static;
use flowy_collaboration::{client_folder::FolderPad, entities::ws_data::ServerRevisionWSData};
use flowy_document::FlowyDocumentManager;
use flowy_document::BlockManager;
use std::{collections::HashMap, convert::TryInto, fmt::Formatter, sync::Arc};
use tokio::sync::RwLock as TokioRwLock;
@ -71,7 +71,7 @@ impl FolderManager {
user: Arc<dyn WorkspaceUser>,
cloud_service: Arc<dyn FolderCouldServiceV1>,
database: Arc<dyn WorkspaceDatabase>,
document_manager: Arc<FlowyDocumentManager>,
document_manager: Arc<BlockManager>,
web_socket: Arc<dyn RevisionWebSocket>,
) -> Self {
if let Ok(user_id) = user.user_id() {

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

@ -63,9 +63,9 @@ pub fn create(folder: Arc<FolderManager>) -> Module {
.event(FolderEvent::UpdateView, update_view_handler)
.event(FolderEvent::DeleteView, delete_view_handler)
.event(FolderEvent::DuplicateView, duplicate_view_handler)
.event(FolderEvent::OpenView, open_document_handler)
.event(FolderEvent::OpenView, open_view_handler)
.event(FolderEvent::CloseView, close_view_handler)
.event(FolderEvent::ApplyDocDelta, document_delta_handler);
.event(FolderEvent::ApplyDocDelta, block_delta_handler);
module = module
.event(FolderEvent::ReadTrash, read_trash_handler)
@ -130,7 +130,7 @@ pub enum FolderEvent {
#[event()]
CopyLink = 206,
#[event(input = "ViewId", output = "DocumentDelta")]
#[event(input = "ViewId", output = "BlockDelta")]
OpenView = 207,
#[event(input = "ViewId")]
@ -151,7 +151,7 @@ pub enum FolderEvent {
#[event()]
DeleteAllTrash = 304,
#[event(input = "DocumentDelta", output = "DocumentDelta")]
#[event(input = "BlockDelta", output = "BlockDelta")]
ApplyDocDelta = 400,
#[event(input = "ExportPayload", output = "ExportData")]

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

@ -6,12 +6,12 @@ use crate::{
errors::FlowyError,
services::{AppController, TrashController, ViewController},
};
use lib_dispatch::prelude::{data_result, Data, DataResult, Unit};
use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
use std::{convert::TryInto, sync::Arc};
pub(crate) async fn create_app_handler(
data: Data<CreateAppPayload>,
controller: Unit<Arc<AppController>>,
controller: AppData<Arc<AppController>>,
) -> DataResult<App, FlowyError> {
let params: CreateAppParams = data.into_inner().try_into()?;
let detail = controller.create_app_from_params(params).await?;
@ -21,8 +21,8 @@ pub(crate) async fn create_app_handler(
pub(crate) async fn delete_app_handler(
data: Data<AppId>,
app_controller: Unit<Arc<AppController>>,
trash_controller: Unit<Arc<TrashController>>,
app_controller: AppData<Arc<AppController>>,
trash_controller: AppData<Arc<TrashController>>,
) -> Result<(), FlowyError> {
let params: AppId = data.into_inner();
let trash = app_controller
@ -39,7 +39,7 @@ pub(crate) async fn delete_app_handler(
#[tracing::instrument(skip(data, controller))]
pub(crate) async fn update_app_handler(
data: Data<UpdateAppPayload>,
controller: Unit<Arc<AppController>>,
controller: AppData<Arc<AppController>>,
) -> Result<(), FlowyError> {
let params: UpdateAppParams = data.into_inner().try_into()?;
let _ = controller.update_app(params).await?;
@ -49,8 +49,8 @@ pub(crate) async fn update_app_handler(
#[tracing::instrument(skip(data, app_controller, view_controller))]
pub(crate) async fn read_app_handler(
data: Data<AppId>,
app_controller: Unit<Arc<AppController>>,
view_controller: Unit<Arc<ViewController>>,
app_controller: AppData<Arc<AppController>>,
view_controller: AppData<Arc<ViewController>>,
) -> DataResult<App, FlowyError> {
let params: AppId = data.into_inner();
let mut app = app_controller.read_app(params.clone()).await?;

8
frontend/rust-lib/flowy-folder/src/services/folder_editor.rs
View File

@ -8,8 +8,8 @@ use crate::controller::FolderId;
use flowy_collaboration::util::make_delta_from_revisions;
use flowy_error::{FlowyError, FlowyResult};
use flowy_sync::{
RevisionCache, RevisionCloudService, RevisionCompact, RevisionManager, RevisionObjectBuilder, RevisionWebSocket,
RevisionWebSocketManager,
RevisionCloudService, RevisionCompact, RevisionManager, RevisionObjectBuilder, RevisionPersistence,
RevisionWebSocket, RevisionWebSocketManager,
};
use lib_infra::future::FutureResult;
use lib_ot::core::PlainAttributes;
@ -33,8 +33,8 @@ impl FolderEditor {
pool: Arc<ConnectionPool>,
web_socket: Arc<dyn RevisionWebSocket>,
) -> FlowyResult<Self> {
let cache = Arc::new(RevisionCache::new(user_id, folder_id.as_ref(), pool));
let mut rev_manager = RevisionManager::new(user_id, folder_id.as_ref(), cache);
let rev_persistence = Arc::new(RevisionPersistence::new(user_id, folder_id.as_ref(), pool));
let mut rev_manager = RevisionManager::new(user_id, folder_id.as_ref(), rev_persistence);
let cloud = Arc::new(FolderRevisionCloudServiceImpl {
token: token.to_string(),
});

12
frontend/rust-lib/flowy-folder/src/services/trash/event_handler.rs
View File

@ -3,12 +3,12 @@ use crate::{
errors::FlowyError,
services::TrashController,
};
use lib_dispatch::prelude::{data_result, Data, DataResult, Unit};
use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
use std::sync::Arc;
#[tracing::instrument(skip(controller), err)]
pub(crate) async fn read_trash_handler(
controller: Unit<Arc<TrashController>>,
controller: AppData<Arc<TrashController>>,
) -> DataResult<RepeatedTrash, FlowyError> {
let repeated_trash = controller.read_trash().await?;
data_result(repeated_trash)
@ -17,7 +17,7 @@ pub(crate) async fn read_trash_handler(
#[tracing::instrument(skip(identifier, controller), err)]
pub(crate) async fn putback_trash_handler(
identifier: Data<TrashId>,
controller: Unit<Arc<TrashController>>,
controller: AppData<Arc<TrashController>>,
) -> Result<(), FlowyError> {
let _ = controller.putback(&identifier.id).await?;
Ok(())
@ -26,20 +26,20 @@ pub(crate) async fn putback_trash_handler(
#[tracing::instrument(skip(identifiers, controller), err)]
pub(crate) async fn delete_trash_handler(
identifiers: Data<RepeatedTrashId>,
controller: Unit<Arc<TrashController>>,
controller: AppData<Arc<TrashController>>,
) -> Result<(), FlowyError> {
let _ = controller.delete(identifiers.into_inner()).await?;
Ok(())
}
#[tracing::instrument(skip(controller), err)]
pub(crate) async fn restore_all_trash_handler(controller: Unit<Arc<TrashController>>) -> Result<(), FlowyError> {
pub(crate) async fn restore_all_trash_handler(controller: AppData<Arc<TrashController>>) -> Result<(), FlowyError> {
let _ = controller.restore_all_trash().await?;
Ok(())
}
#[tracing::instrument(skip(controller), err)]
pub(crate) async fn delete_all_trash_handler(controller: Unit<Arc<TrashController>>) -> Result<(), FlowyError> {
pub(crate) async fn delete_all_trash_handler(controller: AppData<Arc<TrashController>>) -> Result<(), FlowyError> {
let _ = controller.delete_all_trash().await?;
Ok(())
}

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

@ -1,6 +1,6 @@
use bytes::Bytes;
use flowy_collaboration::entities::{
document_info::{DocumentDelta, DocumentId},
document_info::{BlockDelta, BlockId},
revision::{RepeatedRevision, Revision},
};
@ -22,7 +22,7 @@ use crate::{
},
};
use flowy_database::kv::KV;
use flowy_document::FlowyDocumentManager;
use flowy_document::BlockManager;
use flowy_folder_data_model::entities::share::{ExportData, ExportParams};
use lib_infra::uuid_string;
@ -33,7 +33,7 @@ pub(crate) struct ViewController {
cloud_service: Arc<dyn FolderCouldServiceV1>,
persistence: Arc<FolderPersistence>,
trash_controller: Arc<TrashController>,
document_manager: Arc<FlowyDocumentManager>,
block_manager: Arc<BlockManager>,
}
impl ViewController {
@ -42,19 +42,19 @@ impl ViewController {
persistence: Arc<FolderPersistence>,
cloud_service: Arc<dyn FolderCouldServiceV1>,
trash_can: Arc<TrashController>,
document_manager: Arc<FlowyDocumentManager>,
document_manager: Arc<BlockManager>,
) -> Self {
Self {
user,
cloud_service,
persistence,
trash_controller: trash_can,
document_manager,
block_manager: document_manager,
}
}
pub(crate) fn initialize(&self) -> Result<(), FlowyError> {
let _ = self.document_manager.init()?;
let _ = self.block_manager.init()?;
self.listen_trash_can_event();
Ok(())
}
@ -72,7 +72,7 @@ impl ViewController {
let repeated_revision: RepeatedRevision =
Revision::initial_revision(&user_id, &params.view_id, delta_data).into();
let _ = self
.document_manager
.block_manager
.reset_with_revisions(&params.view_id, repeated_revision)
.await?;
let view = self.create_view_on_server(params).await?;
@ -95,7 +95,7 @@ impl ViewController {
let user_id = self.user.user_id()?;
let repeated_revision: RepeatedRevision = Revision::initial_revision(&user_id, view_id, delta_data).into();
let _ = self
.document_manager
.block_manager
.reset_with_revisions(view_id, repeated_revision)
.await?;
Ok(())
@ -143,42 +143,42 @@ impl ViewController {
}
#[tracing::instrument(level = "debug", skip(self), err)]
pub(crate) async fn open_document(&self, doc_id: &str) -> Result<DocumentDelta, FlowyError> {
let editor = self.document_manager.open_document(doc_id).await?;
KV::set_str(LATEST_VIEW_ID, doc_id.to_owned());
let document_json = editor.document_json().await?;
Ok(DocumentDelta {
doc_id: doc_id.to_string(),
pub(crate) async fn open_view(&self, view_id: &str) -> Result<BlockDelta, FlowyError> {
let editor = self.block_manager.open_block(view_id).await?;
KV::set_str(LATEST_VIEW_ID, view_id.to_owned());
let document_json = editor.block_json().await?;
Ok(BlockDelta {
block_id: view_id.to_string(),
delta_json: document_json,
})
}
#[tracing::instrument(level = "debug", skip(self), err)]
pub(crate) async fn close_view(&self, doc_id: &str) -> Result<(), FlowyError> {
let _ = self.document_manager.close_document(doc_id)?;
let _ = self.block_manager.close_block(doc_id)?;
Ok(())
}
#[tracing::instrument(level = "debug", skip(self,params), fields(doc_id = %params.value), err)]
pub(crate) async fn delete_view(&self, params: DocumentId) -> Result<(), FlowyError> {
pub(crate) async fn delete_view(&self, params: BlockId) -> Result<(), FlowyError> {
if let Some(view_id) = KV::get_str(LATEST_VIEW_ID) {
if view_id == params.value {
let _ = KV::remove(LATEST_VIEW_ID);
}
}
let _ = self.document_manager.close_document(&params.value)?;
let _ = self.block_manager.close_block(&params.value)?;
Ok(())
}
#[tracing::instrument(level = "debug", skip(self), err)]
pub(crate) async fn duplicate_view(&self, doc_id: &str) -> Result<(), FlowyError> {
pub(crate) async fn duplicate_view(&self, view_id: &str) -> Result<(), FlowyError> {
let view = self
.persistence
.begin_transaction(|transaction| transaction.read_view(doc_id))
.begin_transaction(|transaction| transaction.read_view(view_id))
.await?;
let editor = self.document_manager.open_document(doc_id).await?;
let document_json = editor.document_json().await?;
let editor = self.block_manager.open_block(view_id).await?;
let document_json = editor.block_json().await?;
let duplicate_params = CreateViewParams {
belong_to_id: view.belong_to_id.clone(),
name: format!("{} (copy)", &view.name),
@ -194,9 +194,9 @@ impl ViewController {
}
#[tracing::instrument(level = "debug", skip(self, params), err)]
pub(crate) async fn export_doc(&self, params: ExportParams) -> Result<ExportData, FlowyError> {
let editor = self.document_manager.open_document(&params.doc_id).await?;
let delta_json = editor.document_json().await?;
pub(crate) async fn export_view(&self, params: ExportParams) -> Result<ExportData, FlowyError> {
let editor = self.block_manager.open_block(&params.view_id).await?;
let delta_json = editor.block_json().await?;
Ok(ExportData {
data: delta_json,
export_type: params.export_type,
@ -234,8 +234,8 @@ impl ViewController {
Ok(view)
}
pub(crate) async fn receive_document_delta(&self, params: DocumentDelta) -> Result<DocumentDelta, FlowyError> {
let doc = self.document_manager.receive_local_delta(params).await?;
pub(crate) async fn receive_delta(&self, params: BlockDelta) -> Result<BlockDelta, FlowyError> {
let doc = self.block_manager.receive_local_delta(params).await?;
Ok(doc)
}
@ -312,7 +312,7 @@ impl ViewController {
fn listen_trash_can_event(&self) {
let mut rx = self.trash_controller.subscribe();
let persistence = self.persistence.clone();
let document_manager = self.document_manager.clone();
let document_manager = self.block_manager.clone();
let trash_controller = self.trash_controller.clone();
let _ = tokio::spawn(async move {
loop {
@ -340,7 +340,7 @@ impl ViewController {
#[tracing::instrument(level = "trace", skip(persistence, document_manager, trash_can))]
async fn handle_trash_event(
persistence: Arc<FolderPersistence>,
document_manager: Arc<FlowyDocumentManager>,
document_manager: Arc<BlockManager>,
trash_can: Arc<TrashController>,
event: TrashEvent,
) {

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

@ -8,14 +8,14 @@ use crate::{
errors::FlowyError,
services::{TrashController, ViewController},
};
use flowy_collaboration::entities::document_info::DocumentDelta;
use flowy_collaboration::entities::document_info::BlockDelta;
use flowy_folder_data_model::entities::share::{ExportData, ExportParams, ExportPayload};
use lib_dispatch::prelude::{data_result, Data, DataResult, Unit};
use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
use std::{convert::TryInto, sync::Arc};
pub(crate) async fn create_view_handler(
data: Data<CreateViewPayload>,
controller: Unit<Arc<ViewController>>,
controller: AppData<Arc<ViewController>>,
) -> DataResult<View, FlowyError> {
let params: CreateViewParams = data.into_inner().try_into()?;
let view = controller.create_view_from_params(params).await?;
@ -24,7 +24,7 @@ pub(crate) async fn create_view_handler(
pub(crate) async fn read_view_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
controller: AppData<Arc<ViewController>>,
) -> DataResult<View, FlowyError> {
let view_id: ViewId = data.into_inner();
let mut view = controller.read_view(view_id.clone()).await?;
@ -38,7 +38,7 @@ pub(crate) async fn read_view_handler(
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn update_view_handler(
data: Data<UpdateViewPayload>,
controller: Unit<Arc<ViewController>>,
controller: AppData<Arc<ViewController>>,
) -> Result<(), FlowyError> {
let params: UpdateViewParams = data.into_inner().try_into()?;
let _ = controller.update_view(params).await?;
@ -46,18 +46,18 @@ pub(crate) async fn update_view_handler(
Ok(())
}
pub(crate) async fn document_delta_handler(
data: Data<DocumentDelta>,
controller: Unit<Arc<ViewController>>,
) -> DataResult<DocumentDelta, FlowyError> {
let doc = controller.receive_document_delta(data.into_inner()).await?;
data_result(doc)
pub(crate) async fn block_delta_handler(
data: Data<BlockDelta>,
controller: AppData<Arc<ViewController>>,
) -> DataResult<BlockDelta, FlowyError> {
let block_delta = controller.receive_delta(data.into_inner()).await?;
data_result(block_delta)
}
pub(crate) async fn delete_view_handler(
data: Data<RepeatedViewId>,
view_controller: Unit<Arc<ViewController>>,
trash_controller: Unit<Arc<TrashController>>,
view_controller: AppData<Arc<ViewController>>,
trash_controller: AppData<Arc<TrashController>>,
) -> Result<(), FlowyError> {
let params: RepeatedViewId = data.into_inner();
for view_id in &params.items {
@ -75,18 +75,18 @@ pub(crate) async fn delete_view_handler(
Ok(())
}
pub(crate) async fn open_document_handler(
pub(crate) async fn open_view_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
) -> DataResult<DocumentDelta, FlowyError> {
controller: AppData<Arc<ViewController>>,
) -> DataResult<BlockDelta, FlowyError> {
let view_id: ViewId = data.into_inner();
let doc = controller.open_document(&view_id.value).await?;
let doc = controller.open_view(&view_id.value).await?;
data_result(doc)
}
pub(crate) async fn close_view_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
controller: AppData<Arc<ViewController>>,
) -> Result<(), FlowyError> {
let view_id: ViewId = data.into_inner();
let _ = controller.close_view(&view_id.value).await?;
@ -96,7 +96,7 @@ pub(crate) async fn close_view_handler(
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn duplicate_view_handler(
data: Data<ViewId>,
controller: Unit<Arc<ViewController>>,
controller: AppData<Arc<ViewController>>,
) -> Result<(), FlowyError> {
let view_id: ViewId = data.into_inner();
let _ = controller.duplicate_view(&view_id.value).await?;
@ -106,9 +106,9 @@ pub(crate) async fn duplicate_view_handler(
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn export_handler(
data: Data<ExportPayload>,
controller: Unit<Arc<ViewController>>,
controller: AppData<Arc<ViewController>>,
) -> DataResult<ExportData, FlowyError> {
let params: ExportParams = data.into_inner().try_into()?;
let data = controller.export_doc(params).await?;
let data = controller.export_view(params).await?;
data_result(data)
}

52
frontend/rust-lib/flowy-folder/src/services/web_socket.rs
View File

@ -21,44 +21,36 @@ pub(crate) async fn make_folder_ws_manager(
web_socket: Arc<dyn RevisionWebSocket>,
folder_pad: Arc<RwLock<FolderPad>>,
) -> Arc<RevisionWebSocketManager> {
let composite_sink_provider = Arc::new(CompositeWSSinkDataProvider::new(folder_id, rev_manager.clone()));
let resolve_target = Arc::new(FolderRevisionResolveTarget { folder_pad });
let resolver = RevisionConflictResolver::<PlainAttributes>::new(
user_id,
resolve_target,
Arc::new(composite_sink_provider.clone()),
rev_manager,
);
let ws_stream_consumer = Arc::new(FolderWSStreamConsumerAdapter {
resolver: Arc::new(resolver),
});
let sink_provider = Arc::new(FolderWSSinkDataProviderAdapter(composite_sink_provider));
let ws_data_provider = Arc::new(WSDataProvider::new(folder_id, Arc::new(rev_manager.clone())));
let resolver = Arc::new(FolderConflictResolver { folder_pad });
let conflict_controller =
ConflictController::<PlainAttributes>::new(user_id, resolver, Arc::new(ws_data_provider.clone()), rev_manager);
let ws_data_stream = Arc::new(FolderRevisionWSDataStream::new(conflict_controller));
let ws_data_sink = Arc::new(FolderWSDataSink(ws_data_provider));
let ping_duration = Duration::from_millis(FOLDER_SYNC_INTERVAL_IN_MILLIS);
Arc::new(RevisionWebSocketManager::new(
"Folder",
folder_id,
web_socket,
sink_provider,
ws_stream_consumer,
ws_data_sink,
ws_data_stream,
ping_duration,
))
}
pub(crate) struct FolderWSSinkDataProviderAdapter(Arc<CompositeWSSinkDataProvider>);
impl RevisionWSSinkDataProvider for FolderWSSinkDataProviderAdapter {
pub(crate) struct FolderWSDataSink(Arc<WSDataProvider>);
impl RevisionWSDataIterator for FolderWSDataSink {
fn next(&self) -> FutureResult<Option<ClientRevisionWSData>, FlowyError> {
let sink_provider = self.0.clone();
FutureResult::new(async move { sink_provider.next().await })
}
}
struct FolderRevisionResolveTarget {
struct FolderConflictResolver {
folder_pad: Arc<RwLock<FolderPad>>,
}
impl ResolverTarget<PlainAttributes> for FolderRevisionResolveTarget {
impl ConflictResolver<PlainAttributes> for FolderConflictResolver {
fn compose_delta(&self, delta: Delta<PlainAttributes>) -> BoxResultFuture<DeltaMD5, FlowyError> {
let folder_pad = self.folder_pad.clone();
Box::pin(async move {
@ -101,18 +93,26 @@ impl ResolverTarget<PlainAttributes> for FolderRevisionResolveTarget {
}
}
struct FolderWSStreamConsumerAdapter {
resolver: Arc<RevisionConflictResolver<PlainAttributes>>,
struct FolderRevisionWSDataStream {
conflict_controller: Arc<ConflictController<PlainAttributes>>,
}
impl RevisionWSSteamConsumer for FolderWSStreamConsumerAdapter {
impl FolderRevisionWSDataStream {
pub fn new(conflict_controller: ConflictController<PlainAttributes>) -> Self {
Self {
conflict_controller: Arc::new(conflict_controller),
}
}
}
impl RevisionWSDataStream for FolderRevisionWSDataStream {
fn receive_push_revision(&self, bytes: Bytes) -> BoxResultFuture<(), FlowyError> {
let resolver = self.resolver.clone();
let resolver = self.conflict_controller.clone();
Box::pin(async move { resolver.receive_bytes(bytes).await })
}
fn receive_ack(&self, id: String, ty: ServerRevisionWSDataType) -> BoxResultFuture<(), FlowyError> {
let resolver = self.resolver.clone();
let resolver = self.conflict_controller.clone();
Box::pin(async move { resolver.ack_revision(id, ty).await })
}
@ -122,7 +122,7 @@ impl RevisionWSSteamConsumer for FolderWSStreamConsumerAdapter {
}
fn pull_revisions_in_range(&self, range: RevisionRange) -> BoxResultFuture<(), FlowyError> {
let resolver = self.resolver.clone();
let resolver = self.conflict_controller.clone();
Box::pin(async move { resolver.send_revisions(range).await })
}
}

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

@ -10,13 +10,13 @@ use flowy_folder_data_model::entities::{
workspace::{CurrentWorkspaceSetting, RepeatedWorkspace, WorkspaceId, *},
};
use lib_dispatch::prelude::{data_result, Data, DataResult, Unit};
use lib_dispatch::prelude::{data_result, AppData, Data, DataResult};
use std::{convert::TryInto, sync::Arc};
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn create_workspace_handler(
data: Data<CreateWorkspacePayload>,
controller: Unit<Arc<WorkspaceController>>,
controller: AppData<Arc<WorkspaceController>>,
) -> DataResult<Workspace, FlowyError> {
let controller = controller.get_ref().clone();
let params: CreateWorkspaceParams = data.into_inner().try_into()?;
@ -26,7 +26,7 @@ pub(crate) async fn create_workspace_handler(
#[tracing::instrument(skip(controller), err)]
pub(crate) async fn read_workspace_apps_handler(
controller: Unit<Arc<WorkspaceController>>,
controller: AppData<Arc<WorkspaceController>>,
) -> DataResult<RepeatedApp, FlowyError> {
let repeated_app = controller.read_current_workspace_apps().await?;
data_result(repeated_app)
@ -35,7 +35,7 @@ pub(crate) async fn read_workspace_apps_handler(
#[tracing::instrument(skip(data, controller), err)]
pub(crate) async fn open_workspace_handler(
data: Data<WorkspaceId>,
controller: Unit<Arc<WorkspaceController>>,
controller: AppData<Arc<WorkspaceController>>,
) -> DataResult<Workspace, FlowyError> {
let params: WorkspaceId = data.into_inner();
let workspaces = controller.open_workspace(params).await?;
@ -45,7 +45,7 @@ pub(crate) async fn open_workspace_handler(
#[tracing::instrument(skip(data, folder), err)]
pub(crate) async fn read_workspaces_handler(
data: Data<WorkspaceId>,
folder: Unit<Arc<FolderManager>>,
folder: AppData<Arc<FolderManager>>,
) -> DataResult<RepeatedWorkspace, FlowyError> {
let params: WorkspaceId = data.into_inner();
let user_id = folder.user.user_id()?;
@ -71,7 +71,7 @@ pub(crate) async fn read_workspaces_handler(
#[tracing::instrument(skip(folder), err)]
pub async fn read_cur_workspace_handler(
folder: Unit<Arc<FolderManager>>,
folder: AppData<Arc<FolderManager>>,
) -> DataResult<CurrentWorkspaceSetting, FlowyError> {
let workspace_id = get_current_workspace()?;
let user_id = folder.user.user_id()?;
@ -96,7 +96,7 @@ pub async fn read_cur_workspace_handler(
#[tracing::instrument(level = "trace", skip(folder_manager), err)]
fn read_workspaces_on_server(
folder_manager: Unit<Arc<FolderManager>>,
folder_manager: AppData<Arc<FolderManager>>,
user_id: String,
params: WorkspaceId,
) -> Result<(), FlowyError> {

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

@ -1,4 +1,4 @@
use flowy_collaboration::entities::document_info::DocumentInfo;
use flowy_collaboration::entities::document_info::BlockInfo;
use flowy_folder::event_map::FolderEvent::*;
use flowy_folder_data_model::entities::view::{RepeatedViewId, ViewId};
use flowy_folder_data_model::entities::workspace::WorkspaceId;
@ -159,14 +159,14 @@ pub async fn delete_view(sdk: &FlowySDKTest, view_ids: Vec<String>) {
.await;
}
pub async fn open_document(sdk: &FlowySDKTest, view_id: &str) -> DocumentInfo {
pub async fn open_document(sdk: &FlowySDKTest, view_id: &str) -> BlockInfo {
let view_id: ViewId = view_id.into();
FolderEventBuilder::new(sdk.clone())
.event(OpenView)
.payload(view_id)
.async_send()
.await
.parse::<DocumentInfo>()
.parse::<BlockInfo>()
}
pub async fn read_trash(sdk: &FlowySDKTest) -> RepeatedTrash {

4
frontend/rust-lib/flowy-folder/tests/workspace/script.rs
View File

@ -1,5 +1,5 @@
use crate::helper::*;
use flowy_collaboration::entities::{document_info::DocumentInfo, revision::RevisionState};
use flowy_collaboration::entities::{document_info::BlockInfo, revision::RevisionState};
use flowy_folder::{errors::ErrorCode, services::folder_editor::FolderEditor};
use flowy_folder_data_model::entities::{
app::{App, RepeatedApp},
@ -58,7 +58,7 @@ pub struct FolderTest {
pub app: App,
pub view: View,
pub trash: Vec<Trash>,
pub document_info: Option<DocumentInfo>,
pub document_info: Option<BlockInfo>,
// pub folder_editor:
}