use std::collections::{HashMap, HashSet};use std::sync::mpsc::SyncSender; use chrono::{DateTime, Duration, Utc};use itertools::Itertools;use rand::Rng;use warp_core::features::FeatureFlag;use warp_errors::report_error;use warp_graphql::scalars::time::ServerTimestamp;use warpui::{AppContext, Entity, ModelContext, SingletonEntity}; use super::generic_string_model::GenericStringObjectId;use crate::ai::execution_profiles::CloudAIExecutionProfile;use crate::auth::AuthStateProvider;use crate::cloud_object::{ CloudModelType, CloudObject, CloudObjectLocation, CloudObjectPermissions, GenericCloudObject, GenericServerObject, GenericStringObjectFormat, JsonObjectType, ObjectIdType, ObjectType, ObjectsToUpdate, Owner, Revision, RevisionAndLastEditor, ServerCloudObject, ServerCreationInfo, ServerFolder, ServerMetadata, ServerNotebook, ServerPermissions, ServerWorkflow, Space,};use crate::drive::folders::{CloudFolder, CloudFolderModel};use crate::drive::{ CloudObjectTypeAndId, DriveIndexVariant, should_auto_open_welcome_folder, write_has_auto_opened_welcome_folder_to_user_defaults,};use crate::env_vars::{CloudEnvVarCollection, CloudEnvVarCollectionModel, EnvVarCollection};use crate::notebooks::CloudNotebook;use crate::persistence::ModelEvent;use crate::server::ids::{ClientId, HashableId, ObjectUid, ServerId, SyncId, ToServerId};use crate::settings::cloud_preferences::{CloudPreference, CloudPreferenceModel};use crate::workflows::workflow::Workflow;use crate::workflows::workflow_enum::{CloudWorkflowEnum, CloudWorkflowEnumModel, WorkflowEnum};use crate::workflows::{CloudWorkflow, CloudWorkflowModel};use crate::workspaces::user_workspaces::UserWorkspaces; // Equivalent to 24 hoursconst MIN_MINUTES_UNTIL_NEXT_FORCE_REFRESH: i64 = 1440; // Equivalent to 36 hoursconst MAX_MINUTES_UNTIL_NEXT_FORCE_REFRESH: i64 = 2160; #[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum UpdateSource { /// This cloud model change came from the server (i.e. an RTC message). Server, /// This cloud model change originated locally (i.e. from a user edit). Local,} #[derive(Debug, Clone, PartialEq, Eq)]pub enum CloudModelEvent { ObjectMoved { type_and_id: CloudObjectTypeAndId, source: UpdateSource, from_folder: Option<SyncId>, to_folder: Option<SyncId>, }, ObjectUpdated { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, ObjectTrashed { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, ObjectUntrashed { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, NotebookEditorChangedFromServer { notebook_id: SyncId, }, ObjectCreated { type_and_id: CloudObjectTypeAndId, }, /// An object was permanently deleted. ObjectDeleted { type_and_id: CloudObjectTypeAndId, /// The parent folder of this object, since it's no longer in the model. folder_id: Option<SyncId>, }, /// An object's permissioned were changed. ObjectPermissionsUpdated { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, /// An object identified by `id` was force expanded. ObjectForceExpanded { id: String, }, /// A SyncId was converted from ClientId to ServerId after successful object creation on the server. ObjectSynced { type_and_id: CloudObjectTypeAndId, client_id: ClientId, server_id: ServerId, }, /// The initial bulk load of cloud objects from the server has completed. InitialLoadCompleted, /// Environment last-task timestamps fetched outside the generic cloud-object sync were merged. EnvironmentLastTaskRunTimestampsUpdated,} enum FolderOpenState { Open, Closed, Reversed,} /// Persistence model for [CloudObject] information. In an ideal world, this singleton model/// is a 1:1 mapping for what we persisting in sqlite, and on the server. Any logic beyond a basic update/// or query to data in [CloudModel] should instead be stored in [CloudViewModel] and tested in/// model_test.rs.pub struct CloudModel { objects_by_id: HashMap<ObjectUid, Box<dyn CloudObject>>, model_event_sender: Option<SyncSender<ModelEvent>>, time_of_next_force_refresh: Option<DateTime<Utc>>,} impl CloudModel { pub fn new( model_event_sender: Option<SyncSender<ModelEvent>>, cached_objects: Vec<Box<dyn CloudObject>>, time_of_next_force_refresh: Option<DateTime<Utc>>, ) -> Self { let objects_by_id = cached_objects .into_iter() .map(|object| (object.uid().to_owned(), object)) .collect::<HashMap<ObjectUid, Box<dyn CloudObject>>>(); Self { objects_by_id, model_event_sender, time_of_next_force_refresh, } } /// This method updates the in-memory object after the CreateObject() endpoint returns successfully. /// It uses the existing client_id to locate the object and then it: /// (1) Sets the object's server_id /// (2) Sets the object's creation statistics (creator_uid) pub fn update_object_after_server_creation( &mut self, client_id: ClientId, server_creation_info: ServerCreationInfo, ctx: &mut ModelContext<Self>, ) { let creator_uid = server_creation_info.creator_uid; let server_id = server_creation_info.server_id_and_type.id; let server_permissions = server_creation_info.permissions; // Use server id for the object going forward. if let Some((_, mut object)) = self.objects_by_id.remove_entry(&client_id.to_string()) { object.set_server_id(server_id); object.metadata_mut().creator_uid = creator_uid; // Update permissions from server response let new_permissions = CloudObjectPermissions::new_from_server(server_permissions); *object.permissions_mut() = new_permissions; let type_and_id = object.cloud_object_type_and_id(); self.objects_by_id.insert(object.uid(), object); // Emit CloudModelEvent for SyncId conversion ctx.emit(CloudModelEvent::ObjectSynced { type_and_id, client_id, server_id, }); ctx.notify(); } } /// Determines whether or not the given object_id can be moved to the given location, based on /// what we currently support from an API perspective. /// /// We do NOT support /// - Moving folders across spaces /// - Transferring from team space to personal space /// - Moving directly into a folder across spaces pub fn can_move_object_to_location( &self, hashed_id: &str, new_location: CloudObjectLocation, app: &AppContext, ) -> bool { // TODO(ben): Update as sharing+moving is supported in more cases. if let Some(object) = self.objects_by_id.get(hashed_id) { let object_space = object.space(app); if let CloudObjectLocation::Space(space) = new_location { if matches!(object_space, Space::Team { .. }) && space == Space::Personal { return false; } if !object.can_move_to_space(space, app) { return false; } } if let CloudObjectLocation::Folder(target_folder_id) = new_location { let folder_to_move: Option<&CloudFolder> = object.into(); if let Some(folder_to_move) = folder_to_move { // We do not want to move a folder into itself. if folder_to_move.id == target_folder_id { return false; } // Since we are trying to move a folder into a folder, we want to ensure that the // target folder is not a child of the folder we are trying to move. let mut target_folder_parent_folder_id = self .get_folder(&target_folder_id) .and_then(|folder| folder.metadata().folder_id); while let Some(parent_id) = target_folder_parent_folder_id { if parent_id == folder_to_move.id { return false; } target_folder_parent_folder_id = self .get_folder(&parent_id) .and_then(|folder| folder.metadata().folder_id); } } if let Some(target_folder) = self.get_folder(&target_folder_id) { // TODO: @ianhodge We do not yet support moving directly into a folder from another space if target_folder.permissions.owner != object.permissions().owner { return false; } } } return true; } false } /// Given a hashed object-id, returns the object's CloudObjectLocation /// (either a folder or top level space) pub fn object_location( &self, hashed_id: &str, app: &AppContext, ) -> Option<CloudObjectLocation> { self.objects_by_id .get(hashed_id) .map(|object| object.location(self, app)) } pub fn set_latest_revision_and_editor( &mut self, uid: &str, revision_and_editor: RevisionAndLastEditor, ctx: &mut ModelContext<Self>, ) { if let Some(object) = self.objects_by_id.get_mut(uid) { object.metadata_mut().revision = Some(revision_and_editor.revision); object.metadata_mut().last_editor_uid = revision_and_editor.last_editor_uid; } ctx.notify(); } /// Checks if the current object has a conflict and clears the conflict if that conflicts revision /// is behind the current revision of the object. We need this because occasionally echo'd back updates /// from RTC will result in a conflict, and we want to clear it once the server response is successful. /// /// This must only be called after the server *accepts* an update. pub fn check_and_maybe_clear_current_conflict( &mut self, uid: &str, ctx: &mut ModelContext<Self>, ) { if let Some(object) = self.objects_by_id.get_mut(uid) && let Some(conflicting_revision) = object.conflicting_object_revision() && let Some(current_revision) = object.metadata().revision { // If the pending conflict is out of date compared to the current revision, clear it. // If we received the RTC update for an edit before the server response, the // conflict's revision may be the same as the current revision. if conflicting_revision <= current_revision { object.clear_conflict_status(); } } ctx.notify(); } pub fn get_by_uid(&self, uid: &ObjectUid) -> Option<&dyn CloudObject> { self.objects_by_id.get(uid).map(|o| o.as_ref()) } pub fn get_mut_by_uid(&mut self, uid: &ObjectUid) -> Option<&mut Box<dyn CloudObject>> { self.objects_by_id.get_mut(uid) } pub fn cloud_objects(&self) -> impl Iterator<Item = &Box<dyn CloudObject>> { self.objects_by_id.values() } pub fn cloud_objects_mut(&mut self) -> impl Iterator<Item = &mut Box<dyn CloudObject>> { self.objects_by_id.values_mut() } pub fn create_object( &mut self, id: SyncId, object: impl CloudObject + 'static, ctx: &mut ModelContext<CloudModel>, ) { ctx.emit(CloudModelEvent::ObjectCreated { type_and_id: object.cloud_object_type_and_id(), }); self.create_object_internal(id, object); ctx.notify(); } // Does not emit events or notify — used during initial load where // InitialLoadCompleted is emitted once afterward instead. fn create_object_internal(&mut self, id: SyncId, object: impl CloudObject + 'static) { self.objects_by_id.insert(id.uid(), Box::new(object)); } pub fn delete_objects_by_id( &mut self, uids: Vec<ObjectUid>, ctx: &mut ModelContext<Self>, ) -> (Vec<(SyncId, ObjectIdType)>, i32) { let mut count = 0; let mut sync_ids_and_types: Vec<(SyncId, ObjectIdType)> = Vec::new(); for uid in uids { if let Some(object) = self.objects_by_id.remove(&uid) { let cloud_object_type_and_id = object.cloud_object_type_and_id(); sync_ids_and_types.push(( cloud_object_type_and_id.sync_id(), cloud_object_type_and_id.object_id_type(), )); ctx.emit(CloudModelEvent::ObjectDeleted { type_and_id: object.cloud_object_type_and_id(), folder_id: object.metadata().folder_id, }); count += 1; } } ctx.notify(); (sync_ids_and_types, count) } /// Remove an object and all its descendants from `CloudModel` recursively. pub fn delete_object_and_descendants( &mut self, uid: ObjectUid, ctx: &mut ModelContext<Self>, ) -> Vec<(SyncId, ObjectIdType)> { let mut accumulator = Vec::new(); self.delete_object_and_descendants_internal(uid, &mut accumulator, ctx); accumulator } fn delete_object_and_descendants_internal( &mut self, uid: ObjectUid, accumulator: &mut Vec<(SyncId, ObjectIdType)>, ctx: &mut ModelContext<Self>, ) { if let Some(object) = self.objects_by_id.remove(&uid) { accumulator.push(( object.sync_id(), object.cloud_object_type_and_id().object_id_type(), )); ctx.emit(CloudModelEvent::ObjectDeleted { type_and_id: object.cloud_object_type_and_id(), folder_id: object.metadata().folder_id, }); if object.object_type() == ObjectType::Folder { let contents = self .objects_by_id .iter() .filter_map(|(child_uid, child)| { if child .metadata() .folder_id .is_some_and(|parent| parent.uid() == uid) { Some(child_uid.clone()) } else { None } }) // Collect into a temporary Vec so that we can can call this mutable method // recursively. .collect_vec(); for child in contents { self.delete_object_and_descendants_internal(child, accumulator, ctx); } } } } pub fn check_if_object_is_in_cloudmodel(&mut self, uid: ObjectUid) -> bool { self.objects_by_id.contains_key(&uid) } /// Updates an existing object from a server response. Returns `None` if the object /// was found and updated, or `Some(id)` if it doesn't exist yet. /// Does not emit events or notify — callers are responsible for that. fn update_cloud_object_if_exists<K, M>( &mut self, server_object: GenericServerObject<K, M>, ) -> Option<SyncId> where K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static, M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static, { let id = server_object.id; let boxed_option = self.get_mut_by_uid(&id.uid()); if let Some(boxed) = boxed_option { let object: Option<&mut GenericCloudObject<K, M>> = boxed.into(); if let Some(object) = object { object.update_from_server_object(server_object); } else { log::warn!( "Unable to update server object. Expected object to implement GenericCloudObject" ); debug_assert!(false, "Unable to update server object. Failed downcast"); } None } else { Some(id) } } /// Update the in-memory object with an update from the server. If the object has not been /// seen before a new object is created. Emits events and notifies. pub fn upsert_from_server_object<K, M>( &mut self, server_object: GenericServerObject<K, M>, ctx: &mut ModelContext<Self>, ) where K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static, M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static, { let id_if_doesnt_exist = self.update_cloud_object_if_exists(server_object.clone()); if let Some(id) = id_if_doesnt_exist { // If we haven't seen the object before--attempt to insert. self.create_object( id, GenericCloudObject::<K, M>::new_from_server(server_object), ctx, ); } else { // Object existed and was updated — emit ObjectUpdated if no conflict. let uid = server_object.id.uid(); if let Some(object) = self.get_by_uid(&uid) && !object.has_conflicting_changes() { ctx.emit(CloudModelEvent::ObjectUpdated { type_and_id: object.cloud_object_type_and_id(), source: UpdateSource::Server, }); } } ctx.notify(); } // Does not emit events or notify — used during initial load where // InitialLoadCompleted is emitted once afterward instead. fn upsert_from_server_object_internal<K, M>(&mut self, server_object: GenericServerObject<K, M>) where K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static, M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static, { let id_if_doesnt_exist = self.update_cloud_object_if_exists(server_object.clone()); if let Some(id) = id_if_doesnt_exist { self.create_object_internal( id, GenericCloudObject::<K, M>::new_from_server(server_object), ); } } /// Update the in-memory notebook with an update from the server. If the object has not been /// seen before--a new object is created. pub fn upsert_from_server_notebook( &mut self, server_notebook: ServerNotebook, ctx: &mut ModelContext<Self>, ) { self.upsert_from_server_object(server_notebook, ctx); } /// Upsert either inserts a new cloud object or updates an existing one. When updating an object, /// this overwrites all fields that are protected by the revision. For fields protected by the metadata ts, /// see update_object_metadata(). pub fn upsert_from_server_cloud_object( &mut self, server_cloud_object: ServerCloudObject, ctx: &mut ModelContext<Self>, ) { match server_cloud_object { ServerCloudObject::Notebook(notebook) => { self.upsert_from_server_notebook(notebook, ctx);Lines 1–500 of 1837. Load more
use std::collections::{HashMap, HashSet}; use std::sync::mpsc::SyncSender; use chrono::{DateTime, Duration, Utc}; use itertools::Itertools; use rand::Rng; use warp_core::features::FeatureFlag; use warp_errors::report_error; use warp_graphql::scalars::time::ServerTimestamp; use warpui::{AppContext, Entity, ModelContext, SingletonEntity}; use super::generic_string_model::GenericStringObjectId; use crate::ai::execution_profiles::CloudAIExecutionProfile; use crate::auth::AuthStateProvider; use crate::cloud_object::{ CloudModelType, CloudObject, CloudObjectLocation, CloudObjectPermissions, GenericCloudObject, GenericServerObject, GenericStringObjectFormat, JsonObjectType, ObjectIdType, ObjectType, ObjectsToUpdate, Owner, Revision, RevisionAndLastEditor, ServerCloudObject, ServerCreationInfo, ServerFolder, ServerMetadata, ServerNotebook, ServerPermissions, ServerWorkflow, Space, }; use crate::drive::folders::{CloudFolder, CloudFolderModel}; use crate::drive::{ CloudObjectTypeAndId, DriveIndexVariant, should_auto_open_welcome_folder, write_has_auto_opened_welcome_folder_to_user_defaults, }; use crate::env_vars::{CloudEnvVarCollection, CloudEnvVarCollectionModel, EnvVarCollection}; use crate::notebooks::CloudNotebook; use crate::persistence::ModelEvent; use crate::server::ids::{ClientId, HashableId, ObjectUid, ServerId, SyncId, ToServerId}; use crate::settings::cloud_preferences::{CloudPreference, CloudPreferenceModel}; use crate::workflows::workflow::Workflow; use crate::workflows::workflow_enum::{CloudWorkflowEnum, CloudWorkflowEnumModel, WorkflowEnum}; use crate::workflows::{CloudWorkflow, CloudWorkflowModel}; use crate::workspaces::user_workspaces::UserWorkspaces; // Equivalent to 24 hours const MIN_MINUTES_UNTIL_NEXT_FORCE_REFRESH: i64 = 1440; // Equivalent to 36 hours const MAX_MINUTES_UNTIL_NEXT_FORCE_REFRESH: i64 = 2160; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum UpdateSource { /// This cloud model change came from the server (i.e. an RTC message). Server, /// This cloud model change originated locally (i.e. from a user edit). Local, } #[derive(Debug, Clone, PartialEq, Eq)] pub enum CloudModelEvent { ObjectMoved { type_and_id: CloudObjectTypeAndId, source: UpdateSource, from_folder: Option<SyncId>, to_folder: Option<SyncId>, }, ObjectUpdated { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, ObjectTrashed { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, ObjectUntrashed { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, NotebookEditorChangedFromServer { notebook_id: SyncId, }, ObjectCreated { type_and_id: CloudObjectTypeAndId, }, /// An object was permanently deleted. ObjectDeleted { type_and_id: CloudObjectTypeAndId, /// The parent folder of this object, since it's no longer in the model. folder_id: Option<SyncId>, }, /// An object's permissioned were changed. ObjectPermissionsUpdated { type_and_id: CloudObjectTypeAndId, source: UpdateSource, }, /// An object identified by `id` was force expanded. ObjectForceExpanded { id: String, }, /// A SyncId was converted from ClientId to ServerId after successful object creation on the server. ObjectSynced { type_and_id: CloudObjectTypeAndId, client_id: ClientId, server_id: ServerId, }, /// The initial bulk load of cloud objects from the server has completed. InitialLoadCompleted, /// Environment last-task timestamps fetched outside the generic cloud-object sync were merged. EnvironmentLastTaskRunTimestampsUpdated, } enum FolderOpenState { Open, Closed, Reversed, } /// Persistence model for [CloudObject] information. In an ideal world, this singleton model /// is a 1:1 mapping for what we persisting in sqlite, and on the server. Any logic beyond a basic update /// or query to data in [CloudModel] should instead be stored in [CloudViewModel] and tested in /// model_test.rs. pub struct CloudModel { objects_by_id: HashMap<ObjectUid, Box<dyn CloudObject>>, model_event_sender: Option<SyncSender<ModelEvent>>, time_of_next_force_refresh: Option<DateTime<Utc>>, } impl CloudModel { pub fn new( model_event_sender: Option<SyncSender<ModelEvent>>, cached_objects: Vec<Box<dyn CloudObject>>, time_of_next_force_refresh: Option<DateTime<Utc>>, ) -> Self { let objects_by_id = cached_objects .into_iter() .map(|object| (object.uid().to_owned(), object)) .collect::<HashMap<ObjectUid, Box<dyn CloudObject>>>(); Self { objects_by_id, model_event_sender, time_of_next_force_refresh, } } /// This method updates the in-memory object after the CreateObject() endpoint returns successfully. /// It uses the existing client_id to locate the object and then it: /// (1) Sets the object's server_id /// (2) Sets the object's creation statistics (creator_uid) pub fn update_object_after_server_creation( &mut self, client_id: ClientId, server_creation_info: ServerCreationInfo, ctx: &mut ModelContext<Self>, ) { let creator_uid = server_creation_info.creator_uid; let server_id = server_creation_info.server_id_and_type.id; let server_permissions = server_creation_info.permissions; // Use server id for the object going forward. if let Some((_, mut object)) = self.objects_by_id.remove_entry(&client_id.to_string()) { object.set_server_id(server_id); object.metadata_mut().creator_uid = creator_uid; // Update permissions from server response let new_permissions = CloudObjectPermissions::new_from_server(server_permissions); *object.permissions_mut() = new_permissions; let type_and_id = object.cloud_object_type_and_id(); self.objects_by_id.insert(object.uid(), object); // Emit CloudModelEvent for SyncId conversion ctx.emit(CloudModelEvent::ObjectSynced { type_and_id, client_id, server_id, }); ctx.notify(); } } /// Determines whether or not the given object_id can be moved to the given location, based on /// what we currently support from an API perspective. /// /// We do NOT support /// - Moving folders across spaces /// - Transferring from team space to personal space /// - Moving directly into a folder across spaces pub fn can_move_object_to_location( &self, hashed_id: &str, new_location: CloudObjectLocation, app: &AppContext, ) -> bool { // TODO(ben): Update as sharing+moving is supported in more cases. if let Some(object) = self.objects_by_id.get(hashed_id) { let object_space = object.space(app); if let CloudObjectLocation::Space(space) = new_location { if matches!(object_space, Space::Team { .. }) && space == Space::Personal { return false; } if !object.can_move_to_space(space, app) { return false; } } if let CloudObjectLocation::Folder(target_folder_id) = new_location { let folder_to_move: Option<&CloudFolder> = object.into(); if let Some(folder_to_move) = folder_to_move { // We do not want to move a folder into itself. if folder_to_move.id == target_folder_id { return false; } // Since we are trying to move a folder into a folder, we want to ensure that the // target folder is not a child of the folder we are trying to move. let mut target_folder_parent_folder_id = self .get_folder(&target_folder_id) .and_then(|folder| folder.metadata().folder_id); while let Some(parent_id) = target_folder_parent_folder_id { if parent_id == folder_to_move.id { return false; } target_folder_parent_folder_id = self .get_folder(&parent_id) .and_then(|folder| folder.metadata().folder_id); } } if let Some(target_folder) = self.get_folder(&target_folder_id) { // TODO: @ianhodge We do not yet support moving directly into a folder from another space if target_folder.permissions.owner != object.permissions().owner { return false; } } } return true; } false } /// Given a hashed object-id, returns the object's CloudObjectLocation /// (either a folder or top level space) pub fn object_location( &self, hashed_id: &str, app: &AppContext, ) -> Option<CloudObjectLocation> { self.objects_by_id .get(hashed_id) .map(|object| object.location(self, app)) } pub fn set_latest_revision_and_editor( &mut self, uid: &str, revision_and_editor: RevisionAndLastEditor, ctx: &mut ModelContext<Self>, ) { if let Some(object) = self.objects_by_id.get_mut(uid) { object.metadata_mut().revision = Some(revision_and_editor.revision); object.metadata_mut().last_editor_uid = revision_and_editor.last_editor_uid; } ctx.notify(); } /// Checks if the current object has a conflict and clears the conflict if that conflicts revision /// is behind the current revision of the object. We need this because occasionally echo'd back updates /// from RTC will result in a conflict, and we want to clear it once the server response is successful. /// /// This must only be called after the server *accepts* an update. pub fn check_and_maybe_clear_current_conflict( &mut self, uid: &str, ctx: &mut ModelContext<Self>, ) { if let Some(object) = self.objects_by_id.get_mut(uid) && let Some(conflicting_revision) = object.conflicting_object_revision() && let Some(current_revision) = object.metadata().revision { // If the pending conflict is out of date compared to the current revision, clear it. // If we received the RTC update for an edit before the server response, the // conflict's revision may be the same as the current revision. if conflicting_revision <= current_revision { object.clear_conflict_status(); } } ctx.notify(); } pub fn get_by_uid(&self, uid: &ObjectUid) -> Option<&dyn CloudObject> { self.objects_by_id.get(uid).map(|o| o.as_ref()) } pub fn get_mut_by_uid(&mut self, uid: &ObjectUid) -> Option<&mut Box<dyn CloudObject>> { self.objects_by_id.get_mut(uid) } pub fn cloud_objects(&self) -> impl Iterator<Item = &Box<dyn CloudObject>> { self.objects_by_id.values() } pub fn cloud_objects_mut(&mut self) -> impl Iterator<Item = &mut Box<dyn CloudObject>> { self.objects_by_id.values_mut() } pub fn create_object( &mut self, id: SyncId, object: impl CloudObject + 'static, ctx: &mut ModelContext<CloudModel>, ) { ctx.emit(CloudModelEvent::ObjectCreated { type_and_id: object.cloud_object_type_and_id(), }); self.create_object_internal(id, object); ctx.notify(); } // Does not emit events or notify — used during initial load where // InitialLoadCompleted is emitted once afterward instead. fn create_object_internal(&mut self, id: SyncId, object: impl CloudObject + 'static) { self.objects_by_id.insert(id.uid(), Box::new(object)); } pub fn delete_objects_by_id( &mut self, uids: Vec<ObjectUid>, ctx: &mut ModelContext<Self>, ) -> (Vec<(SyncId, ObjectIdType)>, i32) { let mut count = 0; let mut sync_ids_and_types: Vec<(SyncId, ObjectIdType)> = Vec::new(); for uid in uids { if let Some(object) = self.objects_by_id.remove(&uid) { let cloud_object_type_and_id = object.cloud_object_type_and_id(); sync_ids_and_types.push(( cloud_object_type_and_id.sync_id(), cloud_object_type_and_id.object_id_type(), )); ctx.emit(CloudModelEvent::ObjectDeleted { type_and_id: object.cloud_object_type_and_id(), folder_id: object.metadata().folder_id, }); count += 1; } } ctx.notify(); (sync_ids_and_types, count) } /// Remove an object and all its descendants from `CloudModel` recursively. pub fn delete_object_and_descendants( &mut self, uid: ObjectUid, ctx: &mut ModelContext<Self>, ) -> Vec<(SyncId, ObjectIdType)> { let mut accumulator = Vec::new(); self.delete_object_and_descendants_internal(uid, &mut accumulator, ctx); accumulator } fn delete_object_and_descendants_internal( &mut self, uid: ObjectUid, accumulator: &mut Vec<(SyncId, ObjectIdType)>, ctx: &mut ModelContext<Self>, ) { if let Some(object) = self.objects_by_id.remove(&uid) { accumulator.push(( object.sync_id(), object.cloud_object_type_and_id().object_id_type(), )); ctx.emit(CloudModelEvent::ObjectDeleted { type_and_id: object.cloud_object_type_and_id(), folder_id: object.metadata().folder_id, }); if object.object_type() == ObjectType::Folder { let contents = self .objects_by_id .iter() .filter_map(|(child_uid, child)| { if child .metadata() .folder_id .is_some_and(|parent| parent.uid() == uid) { Some(child_uid.clone()) } else { None } }) // Collect into a temporary Vec so that we can can call this mutable method // recursively. .collect_vec(); for child in contents { self.delete_object_and_descendants_internal(child, accumulator, ctx); } } } } pub fn check_if_object_is_in_cloudmodel(&mut self, uid: ObjectUid) -> bool { self.objects_by_id.contains_key(&uid) } /// Updates an existing object from a server response. Returns `None` if the object /// was found and updated, or `Some(id)` if it doesn't exist yet. /// Does not emit events or notify — callers are responsible for that. fn update_cloud_object_if_exists<K, M>( &mut self, server_object: GenericServerObject<K, M>, ) -> Option<SyncId> where K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static, M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static, { let id = server_object.id; let boxed_option = self.get_mut_by_uid(&id.uid()); if let Some(boxed) = boxed_option { let object: Option<&mut GenericCloudObject<K, M>> = boxed.into(); if let Some(object) = object { object.update_from_server_object(server_object); } else { log::warn!( "Unable to update server object. Expected object to implement GenericCloudObject" ); debug_assert!(false, "Unable to update server object. Failed downcast"); } None } else { Some(id) } } /// Update the in-memory object with an update from the server. If the object has not been /// seen before a new object is created. Emits events and notifies. pub fn upsert_from_server_object<K, M>( &mut self, server_object: GenericServerObject<K, M>, ctx: &mut ModelContext<Self>, ) where K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static, M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static, { let id_if_doesnt_exist = self.update_cloud_object_if_exists(server_object.clone()); if let Some(id) = id_if_doesnt_exist { // If we haven't seen the object before--attempt to insert. self.create_object( id, GenericCloudObject::<K, M>::new_from_server(server_object), ctx, ); } else { // Object existed and was updated — emit ObjectUpdated if no conflict. let uid = server_object.id.uid(); if let Some(object) = self.get_by_uid(&uid) && !object.has_conflicting_changes() { ctx.emit(CloudModelEvent::ObjectUpdated { type_and_id: object.cloud_object_type_and_id(), source: UpdateSource::Server, }); } } ctx.notify(); } // Does not emit events or notify — used during initial load where // InitialLoadCompleted is emitted once afterward instead. fn upsert_from_server_object_internal<K, M>(&mut self, server_object: GenericServerObject<K, M>) where K: HashableId + ToServerId + std::fmt::Debug + Into<String> + Clone + 'static, M: CloudModelType<IdType = K, CloudObjectType = GenericCloudObject<K, M>> + 'static, { let id_if_doesnt_exist = self.update_cloud_object_if_exists(server_object.clone()); if let Some(id) = id_if_doesnt_exist { self.create_object_internal( id, GenericCloudObject::<K, M>::new_from_server(server_object), ); } } /// Update the in-memory notebook with an update from the server. If the object has not been /// seen before--a new object is created. pub fn upsert_from_server_notebook( &mut self, server_notebook: ServerNotebook, ctx: &mut ModelContext<Self>, ) { self.upsert_from_server_object(server_notebook, ctx); } /// Upsert either inserts a new cloud object or updates an existing one. When updating an object, /// this overwrites all fields that are protected by the revision. For fields protected by the metadata ts, /// see update_object_metadata(). pub fn upsert_from_server_cloud_object( &mut self, server_cloud_object: ServerCloudObject, ctx: &mut ModelContext<Self>, ) { match server_cloud_object { ServerCloudObject::Notebook(notebook) => { self.upsert_from_server_notebook(notebook, ctx);