Genarrative/server-rs/crates/spacetime-client/src/editor_project.rs

use super::*;

impl SpacetimeClient {
    pub async fn create_editor_project(
        &self,
        input: EditorProjectCreateRecordInput,
    ) -> Result<EditorProjectRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "create_editor_project_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .create_editor_project_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_project_required_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn get_recent_editor_project(
        &self,
        owner_user_id: String,
    ) -> Result<Option<EditorProjectRecord>, SpacetimeClientError> {
        let procedure_input = EditorProjectGetRecentInput { owner_user_id };

        self.call_after_connect(
            "get_recent_editor_project_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .get_recent_editor_project_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_project_optional_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn get_editor_project(
        &self,
        input: EditorProjectGetRecordInput,
    ) -> Result<EditorProjectRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "get_editor_project_and_return",
            move |connection, sender| {
                connection.procedures().get_editor_project_and_return_then(
                    procedure_input,
                    move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_project_required_procedure_result);
                        send_once(&sender, mapped);
                    },
                );
            },
        )
        .await
    }

    pub async fn list_editor_projects(
        &self,
        owner_user_id: String,
    ) -> Result<Vec<EditorProjectRecord>, SpacetimeClientError> {
        let procedure_input = EditorProjectListInput { owner_user_id };

        self.call_after_connect(
            "list_editor_projects_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .list_editor_projects_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_project_list_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn rename_editor_project(
        &self,
        input: EditorProjectRenameRecordInput,
    ) -> Result<EditorProjectRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "rename_editor_project_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .rename_editor_project_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_project_required_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn delete_editor_project(
        &self,
        input: EditorProjectDeleteRecordInput,
    ) -> Result<String, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "delete_editor_project_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .delete_editor_project_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_project_delete_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn save_editor_project_layout(
        &self,
        input: EditorProjectLayoutSaveRecordInput,
    ) -> Result<EditorProjectRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "save_editor_project_layout_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .save_editor_project_layout_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_project_required_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn save_editor_project_layout_ack(
        &self,
        input: EditorProjectLayoutSaveRecordInput,
    ) -> Result<EditorProjectLayoutSaveAckRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "save_editor_project_layout_ack",
            move |connection, sender| {
                connection.procedures().save_editor_project_layout_ack_then(
                    procedure_input,
                    move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_project_layout_save_procedure_result);
                        send_once(&sender, mapped);
                    },
                );
            },
        )
        .await
    }

    pub async fn create_editor_project_resource(
        &self,
        input: EditorProjectResourceCreateRecordInput,
    ) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "create_editor_project_resource_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .create_editor_project_resource_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_project_resource_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn repair_editor_project_resource_media(
        &self,
        input: EditorProjectResourceMediaRepairRecordInput,
    ) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "repair_editor_project_resource_media_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .repair_editor_project_resource_media_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_project_resource_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn update_editor_project_resource_showcase(
        &self,
        input: EditorProjectResourceShowcaseUpdateRecordInput,
    ) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "update_editor_project_resource_showcase_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .update_editor_project_resource_showcase_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_project_resource_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn list_public_editor_project_resources(
        &self,
        input: EditorProjectResourcePublicShowcaseListRecordInput,
    ) -> Result<Vec<EditorProjectResourceRecord>, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "list_public_editor_project_resources_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .list_public_editor_project_resources_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_project_resource_list_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn get_editor_asset_library(
        &self,
        owner_user_id: String,
        now_micros: i64,
    ) -> Result<EditorAssetLibraryRecord, SpacetimeClientError> {
        let procedure_input = EditorAssetLibraryGetInput {
            owner_user_id,
            now_micros,
        };

        self.call_after_connect(
            "get_editor_asset_library_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .get_editor_asset_library_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_asset_library_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn create_editor_asset_folder(
        &self,
        input: EditorAssetFolderCreateRecordInput,
    ) -> Result<EditorAssetFolderRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "create_editor_asset_folder_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .create_editor_asset_folder_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_asset_folder_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn update_editor_asset_folder(
        &self,
        input: EditorAssetFolderUpdateRecordInput,
    ) -> Result<EditorAssetFolderRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "update_editor_asset_folder_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .update_editor_asset_folder_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_asset_folder_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn delete_editor_asset_folder(
        &self,
        input: EditorAssetFolderDeleteRecordInput,
    ) -> Result<EditorAssetLibraryRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "delete_editor_asset_folder_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .delete_editor_asset_folder_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_asset_folder_library_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn create_editor_asset(
        &self,
        input: EditorAssetCreateRecordInput,
    ) -> Result<EditorAssetRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "create_editor_asset_and_return",
            move |connection, sender| {
                connection.procedures().create_editor_asset_and_return_then(
                    procedure_input,
                    move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_asset_procedure_result);
                        send_once(&sender, mapped);
                    },
                );
            },
        )
        .await
    }

    pub async fn update_editor_asset(
        &self,
        input: EditorAssetUpdateRecordInput,
    ) -> Result<EditorAssetRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "update_editor_asset_and_return",
            move |connection, sender| {
                connection.procedures().update_editor_asset_and_return_then(
                    procedure_input,
                    move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_asset_procedure_result);
                        send_once(&sender, mapped);
                    },
                );
            },
        )
        .await
    }

    pub async fn repair_editor_asset_media(
        &self,
        input: EditorAssetMediaRepairRecordInput,
    ) -> Result<EditorAssetRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "repair_editor_asset_media_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .repair_editor_asset_media_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_editor_asset_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }

    pub async fn delete_editor_asset(
        &self,
        input: EditorAssetDeleteRecordInput,
    ) -> Result<EditorAssetRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "delete_editor_asset_and_return",
            move |connection, sender| {
                connection.procedures().delete_editor_asset_and_return_then(
                    procedure_input,
                    move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_editor_asset_procedure_result);
                        send_once(&sender, mapped);
                    },
                );
            },
        )
        .await
    }
}