[PM-22256] Add type and default_user_collection_email to collection (#371)

## 🎟️ Tracking
[PM-22256](https://bitwarden.atlassian.net/browse/PM-22256)

## 📔 Objective
This adds type and default user collection email to the Collection
struct. Type is only added to CollectionView. Name is now computed by
the decrypt function of Collection as it is unneeded on the
CollectionView.

[PM-22256]:
https://bitwarden.atlassian.net/browse/PM-22256?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ

Author: jrmccannon

Cargo.lock

@@ -28,6 +28,7 @@ bitwarden-core = { workspace = true, features = ["internal"] }
 bitwarden-crypto = { workspace = true }
 bitwarden-error = { workspace = true }
 serde = { workspace = true }
+serde_repr = { workspace = true }
 thiserror = { workspace = true }
 tsify = { workspace = true, optional = true }
 uniffi = { workspace = true, optional = true }

crates/bitwarden-collections/Cargo.toml

@@ -5,6 +5,7 @@ use bitwarden_core::{
 };
 use bitwarden_crypto::{CryptoError, Decryptable, EncString, IdentifyKey, KeyStoreContext};
 use serde::{Deserialize, Serialize};
+use serde_repr::{Deserialize_repr, Serialize_repr};
 use uuid::Uuid;
 #[cfg(feature = "wasm")]
 use {tsify::Tsify, wasm_bindgen::prelude::*};
@@ -24,6 +25,8 @@ pub struct Collection {
     pub hide_passwords: bool,
     pub read_only: bool,
     pub manage: bool,
+    pub default_user_collection_email: Option<String>,
+    pub r#type: CollectionType,
 }
 
 #[allow(missing_docs)]
@@ -39,6 +42,24 @@ pub struct CollectionView {
     pub hide_passwords: bool,
     pub read_only: bool,
     pub manage: bool,
+    pub r#type: CollectionType,
+}
+
+/// Type of collection
+#[derive(Serialize_repr, Deserialize_repr, Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
+#[cfg_attr(
+    feature = "wasm",
+    derive(tsify::Tsify),
+    tsify(into_wasm_abi, from_wasm_abi)
+)]
+#[repr(u8)]
+pub enum CollectionType {
+    /// Default collection type. Can be assigned by an organization to user(s) or group(s)
+    SharedCollection = 0,
+    /// Default collection assigned to a user for an organization that has
+    /// OrganizationDataOwnership (formerly PersonalOwnership) policy enabled.
+    DefaultUserCollection = 1,
 }
 
 #[allow(missing_docs)]
@@ -48,14 +69,21 @@ impl Decryptable<KeyIds, SymmetricKeyId, CollectionView> for Collection {
         ctx: &mut KeyStoreContext<KeyIds>,
         key: SymmetricKeyId,
     ) -> Result<CollectionView, CryptoError> {
+        let name = self
+            .default_user_collection_email
+            .as_ref()
+            .unwrap_or(&self.name.decrypt(ctx, key)?)
+            .clone();
+
         Ok(CollectionView {
             id: self.id,
             organization_id: self.organization_id,
-            name: self.name.decrypt(ctx, key).ok().unwrap_or_default(),
+            name,
             external_id: self.external_id.clone(),
             hide_passwords: self.hide_passwords,
             read_only: self.read_only,
             manage: self.manage,
+            r#type: self.r#type.clone(),
         })
     }
 }
@@ -73,6 +101,8 @@ impl TryFrom<CollectionDetailsResponseModel> for Collection {
             hide_passwords: collection.hide_passwords.unwrap_or(false),
             read_only: collection.read_only.unwrap_or(false),
             manage: collection.manage.unwrap_or(false),
+            default_user_collection_email: collection.default_user_collection_email,
+            r#type: require!(collection.r#type).into(),
         })
     }
 }
@@ -103,3 +133,132 @@ impl TreeItem for CollectionView {
 
     const DELIMITER: char = '/';
 }
+
+impl From<bitwarden_api_api::models::CollectionType> for CollectionType {
+    fn from(collection_type: bitwarden_api_api::models::CollectionType) -> Self {
+        match collection_type {
+            bitwarden_api_api::models::CollectionType::SharedCollection => Self::SharedCollection,
+            bitwarden_api_api::models::CollectionType::DefaultUserCollection => {
+                Self::DefaultUserCollection
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use bitwarden_core::key_management::{KeyIds, SymmetricKeyId};
+    use bitwarden_crypto::{KeyStore, PrimitiveEncryptable, SymmetricCryptoKey};
+    use uuid::Uuid;
+
+    use super::*;
+
+    const ORGANIZATION_ID: &str = "12345678-1234-1234-1234-123456789012";
+    const COLLECTION_ID: &str = "87654321-4321-4321-4321-210987654321";
+
+    // Helper function to create a test key store with a symmetric key
+    fn create_test_key_store() -> KeyStore<KeyIds> {
+        let store = KeyStore::<KeyIds>::default();
+        let key = SymmetricCryptoKey::make_aes256_cbc_hmac_key();
+        let org_id = Uuid::parse_str(ORGANIZATION_ID).unwrap();
+
+        #[allow(deprecated)]
+        store
+            .context_mut()
+            .set_symmetric_key(SymmetricKeyId::Organization(org_id), key)
+            .unwrap();
+
+        store
+    }
+
+    #[test]
+    fn test_decrypt_with_name_only() {
+        let store = create_test_key_store();
+        let mut ctx = store.context();
+        let org_id = Uuid::parse_str(ORGANIZATION_ID).unwrap();
+        let key = SymmetricKeyId::Organization(org_id);
+
+        let collection_name: &str = "Collection Name";
+
+        let collection = Collection {
+            id: Some(Uuid::parse_str(COLLECTION_ID).unwrap()),
+            organization_id: org_id,
+            name: collection_name.encrypt(&mut ctx, key).unwrap(),
+            external_id: Some("external-id".to_string()),
+            hide_passwords: true,
+            read_only: false,
+            manage: true,
+            default_user_collection_email: None,
+            r#type: CollectionType::SharedCollection,
+        };
+
+        let decrypted = collection.decrypt(&mut ctx, key).unwrap();
+
+        assert_eq!(decrypted.name, collection_name);
+    }
+
+    #[test]
+    fn test_decrypt_with_default_user_collection_email() {
+        let store = create_test_key_store();
+        let mut ctx = store.context();
+        let org_id = Uuid::parse_str(ORGANIZATION_ID).unwrap();
+        let key = SymmetricKeyId::Organization(org_id);
+
+        let collection_name: &str = "Collection Name";
+        let default_user_collection_email = String::from("[email protected]");
+
+        let collection = Collection {
+            id: Some(Uuid::parse_str(COLLECTION_ID).unwrap()),
+            organization_id: org_id,
+            name: collection_name.encrypt(&mut ctx, key).unwrap(),
+            external_id: None,
+            hide_passwords: false,
+            read_only: true,
+            manage: false,
+            default_user_collection_email: Some(default_user_collection_email.clone()),
+            r#type: CollectionType::SharedCollection,
+        };
+
+        let decrypted = collection.decrypt(&mut ctx, key).unwrap();
+
+        assert_ne!(decrypted.name, collection_name);
+        assert_eq!(decrypted.name, default_user_collection_email);
+    }
+
+    #[test]
+    fn test_decrypt_all_fields_preserved() {
+        let store = create_test_key_store();
+        let mut ctx = store.context();
+        let org_id = Uuid::parse_str(ORGANIZATION_ID).unwrap();
+        let key = SymmetricKeyId::Organization(org_id);
+
+        let collection_id = Some(Uuid::parse_str(COLLECTION_ID).unwrap());
+        let external_id = Some("external-test-id".to_string());
+        let collection_name: &str = "Collection Name";
+        let collection_type = CollectionType::SharedCollection;
+
+        let collection = Collection {
+            id: collection_id,
+            organization_id: org_id,
+            name: collection_name.encrypt(&mut ctx, key).unwrap(),
+            external_id: external_id.clone(),
+            hide_passwords: true,
+            read_only: true,
+            manage: true,
+            default_user_collection_email: None,
+            r#type: collection_type.clone(),
+        };
+
+        let decrypted = collection.decrypt(&mut ctx, key).unwrap();
+
+        // Verify all fields are correctly transferred
+        assert_eq!(decrypted.id, collection.id);
+        assert_eq!(decrypted.organization_id, collection.organization_id);
+        assert_eq!(decrypted.name, collection_name);
+        assert_eq!(decrypted.external_id, external_id);
+        assert_eq!(decrypted.hide_passwords, collection.hide_passwords);
+        assert_eq!(decrypted.read_only, collection.read_only);
+        assert_eq!(decrypted.manage, collection.manage);
+        assert_eq!(decrypted.r#type, collection_type);
+    }
+}

crates/bitwarden-collections/src/collection.rs

@@ -110,6 +110,7 @@ impl CollectionViewTree {
 
 #[cfg(test)]
 mod tests {
+    use bitwarden_collections::collection::CollectionType;
     use bitwarden_core::client::test_accounts::test_bitwarden_com_account;
 
     use super::*;
@@ -127,6 +128,8 @@ mod tests {
             hide_passwords: false,
             read_only: false,
             manage: false,
+            default_user_collection_email: None,
+            r#type: CollectionType::SharedCollection,
         }]).unwrap();
 
         assert_eq!(dec[0].name, "Default collection");
@@ -144,6 +147,8 @@ mod tests {
             hide_passwords: false,
             read_only: false,
             manage: false,
+            default_user_collection_email: None,
+            r#type: CollectionType::SharedCollection,
         }).unwrap();
 
         assert_eq!(dec.name, "Default collection");