[PM-25821] Migrate Cipher Admin operation API calls to SDK

crates/bitwarden-vault/src/cipher/cipher.rs

@@ -1,13 +1,10 @@
-use bitwarden_api_api::{
-    apis::ciphers_api::{PutShareError, PutShareManyError},
-    models::{
-        CipherDetailsResponseModel, CipherRequestModel, CipherResponseModel,
-        CipherWithIdRequestModel,
-    },
+use bitwarden_api_api::models::{
+    CipherDetailsResponseModel, CipherMiniDetailsResponseModel, CipherMiniResponseModel,
+    CipherRequestModel, CipherResponseModel, CipherWithIdRequestModel,
 };
 use bitwarden_collections::collection::CollectionId;
 use bitwarden_core::{
-    MissingFieldError, OrganizationId, UserId,
+    ApiError, MissingFieldError, OrganizationId, UserId,
     key_management::{KeyIds, MINIMUM_ENFORCE_ICON_URI_HASH_VERSION, SymmetricKeyId},
     require,
 };
@@ -64,15 +61,19 @@ pub enum CipherError {
     #[error("This cipher cannot be moved to the specified organization")]
     OrganizationAlreadySet,
     #[error(transparent)]
-    PutShare(#[from] bitwarden_api_api::apis::Error<PutShareError>),
-    #[error(transparent)]
-    PutShareMany(#[from] bitwarden_api_api::apis::Error<PutShareManyError>),
-    #[error(transparent)]
     Repository(#[from] RepositoryError),
     #[error(transparent)]
     Chrono(#[from] chrono::ParseError),
     #[error(transparent)]
     SerdeJson(#[from] serde_json::Error),
+    #[error(transparent)]
+    Api(#[from] ApiError),
+}
+
+impl<T> From<bitwarden_api_api::apis::Error<T>> for CipherError {
+    fn from(value: bitwarden_api_api::apis::Error<T>) -> Self {
+        Self::Api(value.into())
+    }
 }
 
 /// Helper trait for operations on cipher types.
@@ -639,6 +640,12 @@ impl Cipher {
         }
         Ok(())
     }
+
+    /// Marks the cipher as soft deleted by setting `deletion_date` to now.
+    pub(crate) fn soft_delete(&mut self) {
+        self.deleted_date = Some(Utc::now());
+        self.archived_date = None;
+    }
 }
 impl CipherView {
     #[allow(missing_docs)]
@@ -973,6 +980,15 @@ impl TryFrom<CipherDetailsResponseModel> for Cipher {
     }
 }
 
+impl PartialCipher for CipherDetailsResponseModel {
+    fn merge_with_cipher(self, cipher: Option<Cipher>) -> Result<Cipher, VaultParseError> {
+        Ok(Cipher {
+            local_data: cipher.and_then(|c| c.local_data),
+            ..self.try_into()?
+        })
+    }
+}
+
 impl From<bitwarden_api_api::models::CipherType> for CipherType {
     fn from(t: bitwarden_api_api::models::CipherType) -> Self {
         match t {
@@ -994,6 +1010,13 @@ impl From<bitwarden_api_api::models::CipherRepromptType> for CipherRepromptType
     }
 }
 
+/// A trait for merging partial cipher data into a full cipher.
+/// Used to convert from API response models to full Cipher structs,
+/// without losing local data that may not be present in the API response.
+pub(crate) trait PartialCipher {
+    fn merge_with_cipher(self, cipher: Option<Cipher>) -> Result<Cipher, VaultParseError>;
+}
+
 impl From<CipherType> for bitwarden_api_api::models::CipherType {
     fn from(t: CipherType) -> Self {
         match t {
@@ -1064,6 +1087,131 @@ impl TryFrom<CipherResponseModel> for Cipher {
     }
 }
 
+impl PartialCipher for CipherMiniResponseModel {
+    fn merge_with_cipher(self, cipher: Option<Cipher>) -> Result<Cipher, VaultParseError> {
+        let cipher = cipher.as_ref();
+        Ok(Cipher {
+            id: self.id.map(CipherId::new),
+            organization_id: self.organization_id.map(OrganizationId::new),
+            key: EncString::try_from_optional(self.key)?,
+            name: require!(EncString::try_from_optional(self.name)?),
+            notes: EncString::try_from_optional(self.notes)?,
+            r#type: require!(self.r#type).into(),
+            login: self.login.map(|l| (*l).try_into()).transpose()?,
+            identity: self.identity.map(|i| (*i).try_into()).transpose()?,
+            card: self.card.map(|c| (*c).try_into()).transpose()?,
+            secure_note: self.secure_note.map(|s| (*s).try_into()).transpose()?,
+            ssh_key: self.ssh_key.map(|s| (*s).try_into()).transpose()?,
+            reprompt: self
+                .reprompt
+                .map(|r| r.into())
+                .unwrap_or(CipherRepromptType::None),
+            organization_use_totp: self.organization_use_totp.unwrap_or(true),
+            attachments: self
+                .attachments
+                .map(|a| a.into_iter().map(|a| a.try_into()).collect())
+                .transpose()?,
+            fields: self
+                .fields
+                .map(|f| f.into_iter().map(|f| f.try_into()).collect())
+                .transpose()?,
+            password_history: self
+                .password_history
+                .map(|p| p.into_iter().map(|p| p.try_into()).collect())
+                .transpose()?,
+            creation_date: require!(self.creation_date)
+                .parse()
+                .map_err(Into::<VaultParseError>::into)?,
+            deleted_date: self
+                .deleted_date
+                .map(|d| d.parse())
+                .transpose()
+                .map_err(Into::<VaultParseError>::into)?,
+            revision_date: require!(self.revision_date)
+                .parse()
+                .map_err(Into::<VaultParseError>::into)?,
+            archived_date: self
+                .archived_date
+                .map(|d| d.parse())
+                .transpose()
+                .map_err(Into::<VaultParseError>::into)?,
+            folder_id: cipher.map_or(Default::default(), |c| c.folder_id),
+            favorite: cipher.map_or(Default::default(), |c| c.favorite),
+            edit: cipher.map_or(Default::default(), |c| c.edit),
+            permissions: cipher.map_or(Default::default(), |c| c.permissions),
+            view_password: cipher.map_or(Default::default(), |c| c.view_password),
+            local_data: cipher.map_or(Default::default(), |c| c.local_data.clone()),
+            data: cipher.map_or(Default::default(), |c| c.data.clone()),
+            collection_ids: cipher.map_or(Default::default(), |c| c.collection_ids.clone()),
+        })
+    }
+}
+
+impl PartialCipher for CipherMiniDetailsResponseModel {
+    fn merge_with_cipher(self, cipher: Option<Cipher>) -> Result<Cipher, VaultParseError> {
+        let cipher = cipher.as_ref();
+        Ok(Cipher {
+            id: self.id.map(CipherId::new),
+            organization_id: self.organization_id.map(OrganizationId::new),
+            key: EncString::try_from_optional(self.key)?,
+            name: require!(EncString::try_from_optional(self.name)?),
+            notes: EncString::try_from_optional(self.notes)?,
+            r#type: require!(self.r#type).into(),
+            login: self.login.map(|l| (*l).try_into()).transpose()?,
+            identity: self.identity.map(|i| (*i).try_into()).transpose()?,
+            card: self.card.map(|c| (*c).try_into()).transpose()?,
+            secure_note: self.secure_note.map(|s| (*s).try_into()).transpose()?,
+            ssh_key: self.ssh_key.map(|s| (*s).try_into()).transpose()?,
+            reprompt: self
+                .reprompt
+                .map(|r| r.into())
+                .unwrap_or(CipherRepromptType::None),
+            organization_use_totp: self.organization_use_totp.unwrap_or(true),
+            attachments: self
+                .attachments
+                .map(|a| a.into_iter().map(|a| a.try_into()).collect())
+                .transpose()?,
+            fields: self
+                .fields
+                .map(|f| f.into_iter().map(|f| f.try_into()).collect())
+                .transpose()?,
+            password_history: self
+                .password_history
+                .map(|p| p.into_iter().map(|p| p.try_into()).collect())
+                .transpose()?,
+            creation_date: require!(self.creation_date)
+                .parse()
+                .map_err(Into::<VaultParseError>::into)?,
+            deleted_date: self
+                .deleted_date
+                .map(|d| d.parse())
+                .transpose()
+                .map_err(Into::<VaultParseError>::into)?,
+            revision_date: require!(self.revision_date)
+                .parse()
+                .map_err(Into::<VaultParseError>::into)?,
+            archived_date: self
+                .archived_date
+                .map(|d| d.parse())
+                .transpose()
+                .map_err(Into::<VaultParseError>::into)?,
+            collection_ids: self
+                .collection_ids
+                .into_iter()
+                .flatten()
+                .map(CollectionId::new)
+                .collect(),
+            folder_id: cipher.map_or(Default::default(), |c| c.folder_id),
+            favorite: cipher.map_or(Default::default(), |c| c.favorite),
+            edit: cipher.map_or(Default::default(), |c| c.edit),
+            permissions: cipher.map_or(Default::default(), |c| c.permissions),
+            view_password: cipher.map_or(Default::default(), |c| c.view_password),
+            data: cipher.map_or(Default::default(), |c| c.data.clone()),
+            local_data: cipher.map_or(Default::default(), |c| c.local_data.clone()),
+        })
+    }
+}
+
 #[cfg(test)]
 mod tests {