fix cargo fmt

src/api/core/ciphers.rs

@@ -1565,7 +1565,7 @@ impl CipherSyncData {
             user_organizations,
             user_collections,
             user_collections_groups,
-            user_groups
+            user_groups,
         }
     }
 }

src/api/core/organizations.rs

@@ -301,7 +301,8 @@ async fn post_organization_collections(
 
     for group in data.Groups {
         CollectionGroup::new(collection.uuid.clone(), group.Id, group.ReadOnly, group.HidePasswords)
-            .save(&conn).await?;
+            .save(&conn)
+            .await?;
     }
 
     // If the user doesn't have access to all collections, only in case of a Manger,
@@ -355,8 +356,7 @@ async fn post_organization_collection_update(
     CollectionGroup::delete_all_by_collection(&col_id, &conn).await?;
 
     for group in data.Groups {
-        CollectionGroup::new(col_id.clone(), group.Id, group.ReadOnly, group.HidePasswords)
+        CollectionGroup::new(col_id.clone(), group.Id, group.ReadOnly, group.HidePasswords).save(&conn).await?;
-            .save(&conn).await?;
     }
 
     Ok(Json(collection.to_json()))
@@ -454,9 +454,12 @@ async fn get_org_collection_detail(
                 err!("Collection is not owned by organization")
             }
 
-            let groups: Vec<Value> = CollectionGroup::find_by_collection(&collection.uuid, &conn).await
+            let groups: Vec<Value> = CollectionGroup::find_by_collection(&collection.uuid, &conn)
+                .await
                 .iter()
-                .map(|collection_group| SelectionReadOnly::to_collection_group_details_read_only(collection_group).to_json())
+                .map(|collection_group| {
+                    SelectionReadOnly::to_collection_group_details_read_only(collection_group).to_json()
+                })
                 .collect();
 
             let mut json_object = collection.to_json();
@@ -1532,10 +1535,7 @@ async fn import(org_id: String, data: JsonUpcase<OrgImportData>, headers: Header
 
 #[get("/organizations/<org_id>/groups")]
 async fn get_groups(org_id: String, _headers: AdminHeaders, conn: DbConn) -> JsonResult {
-    let groups = Group::find_by_organization(&org_id, &conn).await
+    let groups = Group::find_by_organization(&org_id, &conn).await.iter().map(Group::to_json).collect::<Value>();
-        .iter()
-        .map(Group::to_json)
-        .collect::<Value>();
 
     Ok(Json(json!({
         "Data": groups,
@@ -1550,28 +1550,23 @@ struct GroupRequest {
     Name: String,
     AccessAll: Option<bool>,
     ExternalId: String,
-    Collections: Vec<SelectionReadOnly>
+    Collections: Vec<SelectionReadOnly>,
 }
 
 impl GroupRequest {
     pub fn to_group(&self, organizations_uuid: &str) -> Result<Group, String> {
         let access_all_value = match self.AccessAll {
             Some(value) => value,
-            _ => return Err(String::from("Could not convert GroupRequest to Group, because AccessAll has no value!"))
+            _ => return Err(String::from("Could not convert GroupRequest to Group, because AccessAll has no value!")),
         };
 
-        Ok(Group::new(
+        Ok(Group::new(organizations_uuid.to_owned(), self.Name.clone(), access_all_value, self.ExternalId.clone()))
-            organizations_uuid.to_owned(),
-            self.Name.clone(),
-            access_all_value,
-            self.ExternalId.clone()
-        ))
     }
 
     pub fn update_group(&self, mut group: Group) -> Result<Group, String> {
         let access_all_value = match self.AccessAll {
             Some(value) => value,
-            _ => return Err(String::from("Could not update group, because AccessAll has no value!"))
+            _ => return Err(String::from("Could not update group, because AccessAll has no value!")),
         };
 
         group.name = self.Name.clone();
@@ -1587,67 +1582,79 @@ impl GroupRequest {
 struct SelectionReadOnly {
     Id: String,
     ReadOnly: bool,
-    HidePasswords: bool
+    HidePasswords: bool,
 }
 
 impl SelectionReadOnly {
-    pub fn to_collection_group (&self, groups_uuid: String) -> CollectionGroup {
+    pub fn to_collection_group(&self, groups_uuid: String) -> CollectionGroup {
-        CollectionGroup::new (
+        CollectionGroup::new(self.Id.clone(), groups_uuid, self.ReadOnly, self.HidePasswords)
-            self.Id.clone(),
-            groups_uuid,
-            self.ReadOnly,
-            self.HidePasswords
-        )
     }
 
-    pub fn to_group_details_read_only (collection_group: &CollectionGroup) -> SelectionReadOnly {
+    pub fn to_group_details_read_only(collection_group: &CollectionGroup) -> SelectionReadOnly {
         SelectionReadOnly {
             Id: collection_group.collections_uuid.clone(),
             ReadOnly: collection_group.read_only,
-            HidePasswords: collection_group.hide_passwords
+            HidePasswords: collection_group.hide_passwords,
         }
     }
 
-    pub fn to_collection_group_details_read_only (collection_group: &CollectionGroup) -> SelectionReadOnly {
+    pub fn to_collection_group_details_read_only(collection_group: &CollectionGroup) -> SelectionReadOnly {
         SelectionReadOnly {
             Id: collection_group.groups_uuid.clone(),
             ReadOnly: collection_group.read_only,
-            HidePasswords: collection_group.hide_passwords
+            HidePasswords: collection_group.hide_passwords,
         }
     }
 
-    pub fn to_json (&self) -> Value {
+    pub fn to_json(&self) -> Value {
         json!(self)
     }
 }
 
 #[post("/organizations/<_org_id>/groups/<group_id>", data = "<data>")]
-async fn post_group(_org_id: String, group_id: String, data: JsonUpcase<GroupRequest>, _headers: AdminHeaders, conn: DbConn) -> JsonResult {
+async fn post_group(
+    _org_id: String,
+    group_id: String,
+    data: JsonUpcase<GroupRequest>,
+    _headers: AdminHeaders,
+    conn: DbConn,
+) -> JsonResult {
     put_group(_org_id, group_id, data, _headers, conn).await
 }
 
 #[post("/organizations/<org_id>/groups", data = "<data>")]
-async fn post_groups(org_id: String, _headers: AdminHeaders, data: JsonUpcase<GroupRequest>, conn: DbConn) -> JsonResult {    
+async fn post_groups(
+    org_id: String,
+    _headers: AdminHeaders,
+    data: JsonUpcase<GroupRequest>,
+    conn: DbConn,
+) -> JsonResult {
     let group_request = data.into_inner().data;
     let group = match group_request.to_group(&org_id) {
         Ok(group) => group,
-        Err(err) => err!(&err)
+        Err(err) => err!(&err),
     };
 
     add_update_group(group, group_request.Collections, &conn).await
 }
 
 #[put("/organizations/<_org_id>/groups/<group_id>", data = "<data>")]
-async fn put_group(_org_id: String, group_id: String, data: JsonUpcase<GroupRequest>, _headers: AdminHeaders, conn: DbConn) -> JsonResult {
+async fn put_group(
+    _org_id: String,
+    group_id: String,
+    data: JsonUpcase<GroupRequest>,
+    _headers: AdminHeaders,
+    conn: DbConn,
+) -> JsonResult {
     let group = match Group::find_by_uuid(&group_id, &conn).await {
         Some(group) => group,
-        None => err!("Group not found")
+        None => err!("Group not found"),
     };
 
     let group_request = data.into_inner().data;
     let updated_group = match group_request.update_group(group) {
         Ok(group) => group,
-        Err(err) => err!(&err)
+        Err(err) => err!(&err),
     };
 
     CollectionGroup::delete_all_by_group(&group_id, &conn).await?;
@@ -1677,10 +1684,11 @@ async fn add_update_group(mut group: Group, collections: Vec<SelectionReadOnly>,
 async fn get_group_details(_org_id: String, group_id: String, _headers: AdminHeaders, conn: DbConn) -> JsonResult {
     let group = match Group::find_by_uuid(&group_id, &conn).await {
         Some(group) => group,
-        _ => err!("Group could not be found!")
+        _ => err!("Group could not be found!"),
     };
 
-    let collections_groups = CollectionGroup::find_by_group(&group_id, &conn).await
+    let collections_groups = CollectionGroup::find_by_group(&group_id, &conn)
+        .await
         .iter()
         .map(|entry| SelectionReadOnly::to_group_details_read_only(entry).to_json())
         .collect::<Value>();
@@ -1704,7 +1712,7 @@ async fn post_delete_group(org_id: String, group_id: String, _headers: AdminHead
 async fn delete_group(_org_id: String, group_id: String, _headers: AdminHeaders, conn: DbConn) -> EmptyResult {
     let group = match Group::find_by_uuid(&group_id, &conn).await {
         Some(group) => group,
-        _ => err!("Group not found")
+        _ => err!("Group not found"),
     };
 
     group.delete(&conn).await
@@ -1714,7 +1722,7 @@ async fn delete_group(_org_id: String, group_id: String, _headers: AdminHeaders,
 async fn get_group(_org_id: String, group_id: String, _headers: AdminHeaders, conn: DbConn) -> JsonResult {
     let group = match Group::find_by_uuid(&group_id, &conn).await {
         Some(group) => group,
-        _ => err!("Group not found")
+        _ => err!("Group not found"),
     };
 
     Ok(Json(group.to_json()))
@@ -1723,11 +1731,12 @@ async fn get_group(_org_id: String, group_id: String, _headers: AdminHeaders, co
 #[get("/organizations/<_org_id>/groups/<group_id>/users")]
 async fn get_group_users(_org_id: String, group_id: String, _headers: AdminHeaders, conn: DbConn) -> JsonResult {
     match Group::find_by_uuid(&group_id, &conn).await {
-        Some(_) => { /* Do nothing */ },
+        Some(_) => { /* Do nothing */ }
-        _ => err!("Group could not be found!")
+        _ => err!("Group could not be found!"),
     };
 
-    let group_users: Vec<String> = GroupUser::find_by_group(&group_id, &conn).await
+    let group_users: Vec<String> = GroupUser::find_by_group(&group_id, &conn)
+        .await
         .iter()
         .map(|entry| entry.users_organizations_uuid.clone())
         .collect();
@@ -1736,10 +1745,16 @@ async fn get_group_users(_org_id: String, group_id: String, _headers: AdminHeade
 }
 
 #[put("/organizations/<_org_id>/groups/<group_id>/users", data = "<data>")]
-async fn put_group_users(_org_id: String, group_id: String, _headers: AdminHeaders, data: JsonVec<String>, conn: DbConn) -> EmptyResult {        
+async fn put_group_users(
+    _org_id: String,
+    group_id: String,
+    _headers: AdminHeaders,
+    data: JsonVec<String>,
+    conn: DbConn,
+) -> EmptyResult {
     match Group::find_by_uuid(&group_id, &conn).await {
-        Some(_) => { /* Do nothing */ },
+        Some(_) => { /* Do nothing */ }
-        _ => err!("Group could not be found!")
+        _ => err!("Group could not be found!"),
     };
 
     GroupUser::delete_all_by_group(&group_id, &conn).await?;
@@ -1756,14 +1771,12 @@ async fn put_group_users(_org_id: String, group_id: String, _headers: AdminHeade
 #[get("/organizations/<_org_id>/users/<user_id>/groups")]
 async fn get_user_groups(_org_id: String, user_id: String, _headers: AdminHeaders, conn: DbConn) -> JsonResult {
     match UserOrganization::find_by_uuid(&user_id, &conn).await {
-        Some(_) => { /* Do nothing */ },
+        Some(_) => { /* Do nothing */ }
-        _ => err!("User could not be found!")
+        _ => err!("User could not be found!"),
     };
 
-    let user_groups: Vec<String> = GroupUser::find_by_user(&user_id, &conn).await
+    let user_groups: Vec<String> =
-        .iter()
+        GroupUser::find_by_user(&user_id, &conn).await.iter().map(|entry| entry.groups_uuid.clone()).collect();
-        .map(|entry| entry.groups_uuid.clone())
-        .collect();
 
     Ok(Json(json!(user_groups)))
 }
@@ -1771,19 +1784,31 @@ async fn get_user_groups(_org_id: String, user_id: String, _headers: AdminHeader
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct OrganizationUserUpdateGroupsRequest {
-    GroupIds: Vec<String>
+    GroupIds: Vec<String>,
 }
 
-#[post("/organizations/<_org_id>/users/<user_id>/groups", data ="<data>")]
+#[post("/organizations/<_org_id>/users/<user_id>/groups", data = "<data>")]
-async fn post_user_groups(_org_id: String, user_id: String, data: JsonUpcase<OrganizationUserUpdateGroupsRequest>, _headers: AdminHeaders, conn: DbConn) -> EmptyResult {        
+async fn post_user_groups(
+    _org_id: String,
+    user_id: String,
+    data: JsonUpcase<OrganizationUserUpdateGroupsRequest>,
+    _headers: AdminHeaders,
+    conn: DbConn,
+) -> EmptyResult {
     put_user_groups(_org_id, user_id, data, _headers, conn).await
 }
 
-#[put("/organizations/<_org_id>/users/<user_id>/groups", data ="<data>")]
+#[put("/organizations/<_org_id>/users/<user_id>/groups", data = "<data>")]
-async fn put_user_groups(_org_id: String, user_id: String, data: JsonUpcase<OrganizationUserUpdateGroupsRequest>, _headers: AdminHeaders, conn: DbConn) -> EmptyResult {        
+async fn put_user_groups(
+    _org_id: String,
+    user_id: String,
+    data: JsonUpcase<OrganizationUserUpdateGroupsRequest>,
+    _headers: AdminHeaders,
+    conn: DbConn,
+) -> EmptyResult {
     match UserOrganization::find_by_uuid(&user_id, &conn).await {
-        Some(_) => { /* Do nothing */ },
+        Some(_) => { /* Do nothing */ }
-        _ => err!("User could not be found!")
+        _ => err!("User could not be found!"),
     };
 
     GroupUser::delete_all_by_user(&user_id, &conn).await?;
@@ -1798,20 +1823,32 @@ async fn put_user_groups(_org_id: String, user_id: String, data: JsonUpcase<Orga
 }
 
 #[post("/organizations/<org_id>/groups/<group_id>/delete-user/<user_id>")]
-async fn post_delete_group_user(org_id: String, group_id: String, user_id: String, headers: AdminHeaders, conn: DbConn) -> EmptyResult {        
+async fn post_delete_group_user(
+    org_id: String,
+    group_id: String,
+    user_id: String,
+    headers: AdminHeaders,
+    conn: DbConn,
+) -> EmptyResult {
     delete_group_user(org_id, group_id, user_id, headers, conn).await
 }
 
 #[delete("/organizations/<_org_id>/groups/<group_id>/users/<user_id>")]
-async fn delete_group_user(_org_id: String, group_id: String, user_id: String, _headers: AdminHeaders, conn: DbConn) -> EmptyResult {        
+async fn delete_group_user(
+    _org_id: String,
+    group_id: String,
+    user_id: String,
+    _headers: AdminHeaders,
+    conn: DbConn,
+) -> EmptyResult {
     match UserOrganization::find_by_uuid(&user_id, &conn).await {
-        Some(_) => { /* Do nothing */ },
+        Some(_) => { /* Do nothing */ }
-        _ => err!("User could not be found!")
+        _ => err!("User could not be found!"),
     };
 
     match Group::find_by_uuid(&group_id, &conn).await {
-        Some(_) => { /* Do nothing */ },
+        Some(_) => { /* Do nothing */ }
-        _ => err!("Group could not be found!")
+        _ => err!("Group could not be found!"),
     };
 
     GroupUser::delete_by_group_id_and_user_id(&group_id, &user_id, &conn).await

src/db/models/cipher.rs

@@ -2,7 +2,9 @@ use crate::CONFIG;
 use chrono::{Duration, NaiveDateTime, Utc};
 use serde_json::Value;
 
-use super::{Attachment, CollectionCipher, Favorite, FolderCipher, User, UserOrgStatus, UserOrgType, UserOrganization, Group};
+use super::{
+    Attachment, CollectionCipher, Favorite, FolderCipher, Group, User, UserOrgStatus, UserOrgType, UserOrganization,
+};
 
 use crate::api::core::CipherSyncData;
 
@@ -362,12 +364,8 @@ impl Cipher {
         conn: &DbConn,
     ) -> bool {
         match cipher_sync_data {
-            Some(cipher_sync_data) => {
+            Some(cipher_sync_data) => cipher_sync_data.user_groups.iter().any(|group| group.access_all),
-                cipher_sync_data.user_groups.iter().any(|group| group.access_all)
+            None => Group::is_in_full_access_group(user_uuid, conn).await,
-            },
-            None => {
-                Group::is_in_full_access_group(user_uuid, conn).await
-            }
         }
     }
 
@@ -385,7 +383,10 @@ impl Cipher {
         // Check whether this cipher is directly owned by the user, or is in
         // a collection that the user has full access to. If so, there are no
         // access restrictions.
-        if self.is_owned_by_user(user_uuid) || self.is_in_full_access_org(user_uuid, cipher_sync_data, conn).await || self.is_in_full_access_group(user_uuid, cipher_sync_data, conn).await {
+        if self.is_owned_by_user(user_uuid)
+            || self.is_in_full_access_org(user_uuid, cipher_sync_data, conn).await
+            || self.is_in_full_access_group(user_uuid, cipher_sync_data, conn).await
+        {
             return Some((false, false));
         }
 
@@ -399,9 +400,11 @@ impl Cipher {
                     }
 
                     //Group permissions
-                    if let Some(gc) = cipher_sync_data.user_collections_groups
+                    if let Some(gc) = cipher_sync_data
+                        .user_collections_groups
                         .iter()
-                        .find(|collection_group| collection_group.collections_uuid == collection.clone()) {
+                        .find(|collection_group| collection_group.collections_uuid == collection.clone())
+                    {
                         rows.push((gc.read_only, gc.hide_passwords));
                     }
                 }

src/db/models/collection.rs

@@ -1,6 +1,6 @@
 use serde_json::Value;
 
-use super::{User, UserOrgStatus, UserOrgType, UserOrganization, CollectionGroup};
+use super::{CollectionGroup, User, UserOrgStatus, UserOrgType, UserOrganization};
 
 db_object! {
     #[derive(Identifiable, Queryable, Insertable, AsChangeset)]

src/db/models/group.rs

@@ -1,5 +1,5 @@
-use serde_json::Value;
 use chrono::{NaiveDateTime, Utc};
+use serde_json::Value;
 
 db_object! {
     #[derive(Identifiable, Queryable, Insertable, AsChangeset)]
@@ -46,7 +46,7 @@ impl Group {
             access_all,
             external_id,
             creation_date: now,
-            revision_date: now
+            revision_date: now,
         }
     }
 
@@ -71,16 +71,16 @@ impl CollectionGroup {
             collections_uuid,
             groups_uuid,
             read_only,
-            hide_passwords
+            hide_passwords,
         }
     }
 }
 
 impl GroupUser {
-    pub fn new (groups_uuid: String, users_organizations_uuid: String) -> Self {
+    pub fn new(groups_uuid: String, users_organizations_uuid: String) -> Self {
         Self {
             groups_uuid,
-            users_organizations_uuid
+            users_organizations_uuid,
         }
     }
 }
@@ -90,7 +90,7 @@ use crate::db::DbConn;
 use crate::api::EmptyResult;
 use crate::error::MapResult;
 
-use super::{UserOrganization, User};
+use super::{User, UserOrganization};
 
 /// Database methods
 impl Group {
@@ -128,7 +128,7 @@ impl Group {
         }
     }
 
-    pub async fn find_by_organization (organizations_uuid: &str, conn: &DbConn) -> Vec<Self> {
+    pub async fn find_by_organization(organizations_uuid: &str, conn: &DbConn) -> Vec<Self> {
         db_run! { conn: {
             groups::table
                 .filter(groups::organizations_uuid.eq(organizations_uuid))
@@ -138,7 +138,7 @@ impl Group {
         }}
     }
 
-    pub async fn find_by_uuid (uuid: &str, conn: &DbConn) -> Option<Self> {
+    pub async fn find_by_uuid(uuid: &str, conn: &DbConn) -> Option<Self> {
         db_run! { conn: {
             groups::table
                 .filter(groups::uuid.eq(uuid))
@@ -267,7 +267,7 @@ impl CollectionGroup {
         }
     }
 
-    pub async fn find_by_group (group_uuid: &str, conn: &DbConn) -> Vec<Self> {
+    pub async fn find_by_group(group_uuid: &str, conn: &DbConn) -> Vec<Self> {
         db_run! { conn: {
             collections_groups::table
                 .filter(collections_groups::groups_uuid.eq(group_uuid))
@@ -422,14 +422,18 @@ impl GroupUser {
     pub async fn update_user_revision(&self, conn: &DbConn) {
         match UserOrganization::find_by_uuid(&self.users_organizations_uuid, conn).await {
             Some(user) => User::update_uuid_revision(&user.user_uuid, conn).await,
-            None => warn!("User could not be found!")
+            None => warn!("User could not be found!"),
         }
     }
 
-    pub async fn delete_by_group_id_and_user_id(group_uuid: &str, users_organizations_uuid: &str, conn: &DbConn) -> EmptyResult {        
+    pub async fn delete_by_group_id_and_user_id(
+        group_uuid: &str,
+        users_organizations_uuid: &str,
+        conn: &DbConn,
+    ) -> EmptyResult {
         match UserOrganization::find_by_uuid(users_organizations_uuid, conn).await {
             Some(user) => User::update_uuid_revision(&user.user_uuid, conn).await,
-            None => warn!("User could not be found!")
+            None => warn!("User could not be found!"),
         };
 
         db_run! { conn: {
@@ -458,7 +462,7 @@ impl GroupUser {
     pub async fn delete_all_by_user(users_organizations_uuid: &str, conn: &DbConn) -> EmptyResult {
         match UserOrganization::find_by_uuid(users_organizations_uuid, conn).await {
             Some(user) => User::update_uuid_revision(&user.user_uuid, conn).await,
-            None => warn!("User could not be found!")
+            None => warn!("User could not be found!"),
         }
 
         db_run! { conn: {

src/db/models/mod.rs

@@ -5,13 +5,13 @@ mod device;
 mod emergency_access;
 mod favorite;
 mod folder;
+mod group;
 mod org_policy;
 mod organization;
 mod send;
 mod two_factor;
 mod two_factor_incomplete;
 mod user;
-mod group;
 
 pub use self::attachment::Attachment;
 pub use self::cipher::Cipher;
@@ -20,10 +20,10 @@ pub use self::device::Device;
 pub use self::emergency_access::{EmergencyAccess, EmergencyAccessStatus, EmergencyAccessType};
 pub use self::favorite::Favorite;
 pub use self::folder::{Folder, FolderCipher};
+pub use self::group::{CollectionGroup, Group, GroupUser};
 pub use self::org_policy::{OrgPolicy, OrgPolicyType};
 pub use self::organization::{Organization, UserOrgStatus, UserOrgType, UserOrganization};
 pub use self::send::{Send, SendType};
 pub use self::two_factor::{TwoFactor, TwoFactorType};
 pub use self::two_factor_incomplete::TwoFactorIncomplete;
 pub use self::user::{Invitation, User, UserStampException};
-pub use self::group::{Group, CollectionGroup, GroupUser};

src/db/models/organization.rs

@@ -2,7 +2,7 @@ use num_traits::FromPrimitive;
 use serde_json::Value;
 use std::cmp::Ordering;
 
-use super::{CollectionUser, OrgPolicy, OrgPolicyType, User, GroupUser};
+use super::{CollectionUser, GroupUser, OrgPolicy, OrgPolicyType, User};
 
 db_object! {
     #[derive(Identifiable, Queryable, Insertable, AsChangeset)]