test read file & save file in flowy-editor

rust-lib/flowy-workspace/src/handlers/app_handler.rs

@@ -15,7 +15,7 @@ pub async fn create_app(
     controller: ModuleData<Arc<AppController>>,
 ) -> ResponseResult<App, WorkspaceError> {
     let params: CreateAppParams = data.into_inner().try_into()?;
-    let detail = controller.save_app(params)?;
+    let detail = controller.create_app(params)?;
     response_ok(detail)
 }
 
@@ -25,9 +25,9 @@ pub async fn get_app(
     controller: ModuleData<Arc<AppController>>,
 ) -> ResponseResult<App, WorkspaceError> {
     let params: QueryAppParams = data.into_inner().try_into()?;
-    let mut app = controller.get_app(&params.app_id).await?;
+    let mut app = controller.read_app(&params.app_id).await?;
     if params.read_views {
-        let views = controller.get_views(&params.app_id).await?;
+        let views = controller.read_views(&params.app_id).await?;
         app.views = RepeatedView { items: views };
     }
 

rust-lib/flowy-workspace/src/handlers/view_handler.rs

@@ -11,6 +11,6 @@ pub async fn create_view(
     controller: ModuleData<Arc<ViewController>>,
 ) -> ResponseResult<View, WorkspaceError> {
     let params: CreateViewParams = data.into_inner().try_into()?;
-    let view = controller.save_view(params).await?;
+    let view = controller.create_view(params).await?;
     response_ok(view)
 }

rust-lib/flowy-workspace/src/handlers/workspace_handler.rs

@@ -13,7 +13,7 @@ pub async fn create_workspace(
 ) -> ResponseResult<Workspace, WorkspaceError> {
     let controller = controller.get_ref().clone();
     let params: CreateWorkspaceParams = data.into_inner().try_into()?;
-    let detail = controller.save_workspace(params).await?;
+    let detail = controller.create_workspace(params).await?;
     response_ok(detail)
 }
 
@@ -21,7 +21,7 @@ pub async fn create_workspace(
 pub async fn get_cur_workspace(
     controller: ModuleData<Arc<WorkspaceController>>,
 ) -> ResponseResult<Workspace, WorkspaceError> {
-    let workspace = controller.get_cur_workspace().await?;
+    let workspace = controller.read_cur_workspace().await?;
     response_ok(workspace)
 }
 
@@ -31,10 +31,10 @@ pub async fn get_workspace(
     controller: ModuleData<Arc<WorkspaceController>>,
 ) -> ResponseResult<Workspace, WorkspaceError> {
     let params: QueryWorkspaceParams = data.into_inner().try_into()?;
-    let mut workspace = controller.get_workspace(&params.workspace_id).await?;
+    let mut workspace = controller.read_workspace(&params.workspace_id).await?;
 
     if params.read_apps {
-        let apps = controller.get_apps(&params.workspace_id).await?;
+        let apps = controller.read_apps(&params.workspace_id).await?;
         workspace.apps = RepeatedApp { items: apps };
     }
 

rust-lib/flowy-workspace/src/services/app_controller.rs

@@ -32,28 +32,28 @@ impl AppController {
         }
     }
 
-    pub fn save_app(&self, params: CreateAppParams) -> Result<App, WorkspaceError> {
+    pub fn create_app(&self, params: CreateAppParams) -> Result<App, WorkspaceError> {
         let app_table = AppTable::new(params);
         let app: App = app_table.clone().into();
-        let _ = self.sql.write_app_table(app_table)?;
+        let _ = self.sql.create_app(app_table)?;
         send_observable(&app.workspace_id, WorkspaceObservable::WorkspaceAddApp);
         Ok(app)
     }
 
-    pub async fn get_app(&self, app_id: &str) -> Result<App, WorkspaceError> {
-        let app_table = self.get_app_table(app_id).await?;
+    pub async fn read_app(&self, app_id: &str) -> Result<App, WorkspaceError> {
+        let app_table = self.async_read_app(&app_id).await?;
         Ok(app_table.into())
     }
 
     pub fn update_app(&self, params: UpdateAppParams) -> Result<(), WorkspaceError> {
         let changeset = AppTableChangeset::new(params);
         let app_id = changeset.id.clone();
-        let _ = self.sql.update_app_table(changeset)?;
+        let _ = self.sql.update_app(changeset)?;
         send_observable(&app_id, WorkspaceObservable::AppUpdateDesc);
         Ok(())
     }
 
-    pub async fn get_views(&self, app_id: &str) -> Result<Vec<View>, WorkspaceError> {
+    pub async fn read_views(&self, app_id: &str) -> Result<Vec<View>, WorkspaceError> {
         let views = self
             .sql
             .read_views_belong_to_app(app_id)?
@@ -64,12 +64,12 @@ impl AppController {
         Ok(views)
     }
 
-    fn get_app_table(&self, app_id: &str) -> DispatchFuture<Result<AppTable, WorkspaceError>> {
+    fn async_read_app(&self, app_id: &str) -> DispatchFuture<Result<AppTable, WorkspaceError>> {
         let sql = self.sql.clone();
         let app_id = app_id.to_owned();
         DispatchFuture {
             fut: Box::pin(async move {
-                let app_table = sql.read_app_table(&app_id)?;
+                let app_table = sql.read_app(&app_id)?;
                 // TODO: fetch app from remote server
                 Ok(app_table)
             }),

rust-lib/flowy-workspace/src/services/view_controller.rs

@@ -17,10 +17,10 @@ impl ViewController {
         Self { sql }
     }
 
-    pub async fn save_view(&self, params: CreateViewParams) -> Result<View, WorkspaceError> {
+    pub async fn create_view(&self, params: CreateViewParams) -> Result<View, WorkspaceError> {
         let view_table = ViewTable::new(params);
         let view: View = view_table.clone().into();
-        let _ = self.sql.write_view_table(view_table)?;
+        let _ = self.sql.create_view(view_table)?;
 
         send_observable(&view.id, WorkspaceObservable::AppAddView);
         Ok(view)

rust-lib/flowy-workspace/src/services/workspace_controller.rs

@@ -29,13 +29,13 @@ impl WorkspaceController {
         }
     }
 
-    pub async fn save_workspace(
+    pub async fn create_workspace(
         &self,
         params: CreateWorkspaceParams,
     ) -> Result<Workspace, WorkspaceError> {
         let workspace_table = WorkspaceTable::new(params);
         let detail: Workspace = workspace_table.clone().into();
-        let _ = self.sql.write_workspace_table(workspace_table)?;
+        let _ = self.sql.create_workspace(workspace_table)?;
         let _ = self.user.set_cur_workspace_id(&detail.id).await?;
 
         Ok(detail)
@@ -54,24 +54,24 @@ impl WorkspaceController {
         unimplemented!()
     }
 
-    pub async fn get_cur_workspace(&self) -> Result<Workspace, WorkspaceError> {
+    pub async fn read_cur_workspace(&self) -> Result<Workspace, WorkspaceError> {
         let user_workspace = self.user.get_cur_workspace().await?;
-        let workspace = self.get_workspace(&user_workspace.workspace_id).await?;
+        let workspace = self.read_workspace(&user_workspace.workspace_id).await?;
         Ok(workspace)
     }
 
-    pub async fn get_cur_apps(&self) -> Result<Vec<App>, WorkspaceError> {
+    pub async fn read_cur_apps(&self) -> Result<Vec<App>, WorkspaceError> {
         let user_workspace = self.user.get_cur_workspace().await?;
-        let apps = self.get_apps(&user_workspace.workspace_id).await?;
+        let apps = self.read_apps(&user_workspace.workspace_id).await?;
         Ok(apps)
     }
 
-    pub async fn get_workspace(&self, workspace_id: &str) -> Result<Workspace, WorkspaceError> {
-        let workspace_table = self.get_workspace_table(workspace_id).await?;
+    pub async fn read_workspace(&self, workspace_id: &str) -> Result<Workspace, WorkspaceError> {
+        let workspace_table = self.read_workspace_table(workspace_id).await?;
         Ok(workspace_table.into())
     }
 
-    pub async fn get_apps(&self, workspace_id: &str) -> Result<Vec<App>, WorkspaceError> {
+    pub async fn read_apps(&self, workspace_id: &str) -> Result<Vec<App>, WorkspaceError> {
         let apps = self
             .sql
             .read_apps_belong_to_workspace(workspace_id)?
@@ -82,7 +82,7 @@ impl WorkspaceController {
         Ok(apps)
     }
 
-    fn get_workspace_table(
+    fn read_workspace_table(
         &self,
         workspace_id: &str,
     ) -> DispatchFuture<Result<WorkspaceTable, WorkspaceError>> {

rust-lib/flowy-workspace/src/sql_tables/app/app_sql.rs

@@ -18,7 +18,7 @@ pub struct AppTableSql {
 }
 
 impl AppTableSql {
-    pub(crate) fn write_app_table(&self, app_table: AppTable) -> Result<(), WorkspaceError> {
+    pub(crate) fn create_app(&self, app_table: AppTable) -> Result<(), WorkspaceError> {
         let conn = self.database.db_connection()?;
         let _ = diesel::insert_into(app_table::table)
             .values(app_table)
@@ -26,16 +26,13 @@ impl AppTableSql {
         Ok(())
     }
 
-    pub(crate) fn update_app_table(
-        &self,
-        changeset: AppTableChangeset,
-    ) -> Result<(), WorkspaceError> {
+    pub(crate) fn update_app(&self, changeset: AppTableChangeset) -> Result<(), WorkspaceError> {
         let conn = self.database.db_connection()?;
         diesel_update_table!(app_table, changeset, conn);
         Ok(())
     }
 
-    pub(crate) fn read_app_table(&self, app_id: &str) -> Result<AppTable, WorkspaceError> {
+    pub(crate) fn read_app(&self, app_id: &str) -> Result<AppTable, WorkspaceError> {
         let app_table = dsl::app_table
             .filter(app_table::id.eq(app_id))
             .first::<AppTable>(&*(self.database.db_connection()?))?;

rust-lib/flowy-workspace/src/sql_tables/view/view_sql.rs

@@ -11,7 +11,7 @@ pub struct ViewTableSql {
 }
 
 impl ViewTableSql {
-    pub(crate) fn write_view_table(&self, view_table: ViewTable) -> Result<(), WorkspaceError> {
+    pub(crate) fn create_view(&self, view_table: ViewTable) -> Result<(), WorkspaceError> {
         let conn = self.database.db_connection()?;
         let _ = diesel::insert_into(view_table::table)
             .values(view_table)

rust-lib/flowy-workspace/src/sql_tables/workspace/workspace_sql.rs

@@ -17,10 +17,7 @@ pub struct WorkspaceSql {
 }
 
 impl WorkspaceSql {
-    pub fn write_workspace_table(
-        &self,
-        workspace_table: WorkspaceTable,
-    ) -> Result<(), WorkspaceError> {
+    pub fn create_workspace(&self, workspace_table: WorkspaceTable) -> Result<(), WorkspaceError> {
         let _ = diesel::insert_into(workspace_table::table)
             .values(workspace_table)
             .execute(&*(self.database.db_connection()?))?;

rust-lib/flowy-workspace/tests/event/app_test.rs

@@ -1,5 +1,5 @@
 use crate::helper::*;
-use flowy_test::builder::WorkspaceTestBuilder;
+use flowy_test::builder::SingleUserTestBuilder;
 use flowy_workspace::{
     entities::{
         app::{App, CreateAppRequest, QueryAppRequest},

rust-lib/flowy-workspace/tests/event/helper.rs

@@ -1,4 +1,4 @@
-pub use flowy_test::builder::WorkspaceTestBuilder;
+pub use flowy_test::builder::SingleUserTestBuilder;
 use flowy_workspace::{
     entities::{app::*, view::*, workspace::*},
     event::WorkspaceEvent::*,
@@ -17,7 +17,7 @@ pub fn create_workspace(name: &str, desc: &str) -> Workspace {
         desc: desc.to_owned(),
     };
 
-    let workspace = WorkspaceTestBuilder::new()
+    let workspace = SingleUserTestBuilder::new()
         .event(CreateWorkspace)
         .request(request)
         .sync_send()
@@ -34,7 +34,7 @@ pub fn create_app(name: &str, desc: &str, workspace_id: &str) -> App {
         color_style: Default::default(),
     };
 
-    let app = WorkspaceTestBuilder::new()
+    let app = SingleUserTestBuilder::new()
         .event(CreateApp)
         .request(create_app_request)
         .sync_send()
@@ -43,7 +43,7 @@ pub fn create_app(name: &str, desc: &str, workspace_id: &str) -> App {
 }
 
 pub fn get_workspace(request: QueryWorkspaceRequest) -> Workspace {
-    let workspace = WorkspaceTestBuilder::new()
+    let workspace = SingleUserTestBuilder::new()
         .event(GetWorkspace)
         .request(request)
         .sync_send()
@@ -53,7 +53,7 @@ pub fn get_workspace(request: QueryWorkspaceRequest) -> Workspace {
 }
 
 pub fn get_app(request: QueryAppRequest) -> App {
-    let app = WorkspaceTestBuilder::new()
+    let app = SingleUserTestBuilder::new()
         .event(GetApp)
         .request(request)
         .sync_send()
@@ -63,7 +63,7 @@ pub fn get_app(request: QueryAppRequest) -> App {
 }
 
 pub fn create_view(request: CreateViewRequest) -> View {
-    let view = WorkspaceTestBuilder::new()
+    let view = SingleUserTestBuilder::new()
         .event(CreateView)
         .request(request)
         .sync_send()

rust-lib/flowy-workspace/tests/event/workspace_test.rs

@@ -14,7 +14,7 @@ fn workspace_create_success() { let _ = create_workspace("First workspace", "");
 
 #[test]
 fn workspace_get_success() {
-    let workspace = WorkspaceTestBuilder::new()
+    let workspace = SingleUserTestBuilder::new()
         .event(GetCurWorkspace)
         .sync_send()
         .parse::<Workspace>();
@@ -60,7 +60,7 @@ fn workspace_create_with_invalid_name_test() {
         };
 
         assert_eq!(
-            WorkspaceTestBuilder::new()
+            SingleUserTestBuilder::new()
                 .event(CreateWorkspace)
                 .request(request)
                 .sync_send()
@@ -80,7 +80,7 @@ fn workspace_update_with_invalid_name_test() {
         };
 
         assert_eq!(
-            WorkspaceTestBuilder::new()
+            SingleUserTestBuilder::new()
                 .event(CreateWorkspace)
                 .request(request)
                 .sync_send()