|
|
|
@ -1,7 +1,6 @@
|
|
|
|
use std::collections::{HashMap, HashSet};
|
|
|
|
use std::collections::{HashMap, HashSet};
|
|
|
|
|
|
|
|
|
|
|
|
use chrono::{NaiveDateTime, Utc};
|
|
|
|
use chrono::{NaiveDateTime, Utc};
|
|
|
|
use futures::{stream, stream::StreamExt};
|
|
|
|
|
|
|
|
use rocket::fs::TempFile;
|
|
|
|
use rocket::fs::TempFile;
|
|
|
|
use rocket::serde::json::Json;
|
|
|
|
use rocket::serde::json::Json;
|
|
|
|
use rocket::{
|
|
|
|
use rocket::{
|
|
|
|
@ -85,8 +84,8 @@ pub fn routes() -> Vec<Route> {
|
|
|
|
|
|
|
|
|
|
|
|
pub async fn purge_trashed_ciphers(pool: DbPool) {
|
|
|
|
pub async fn purge_trashed_ciphers(pool: DbPool) {
|
|
|
|
debug!("Purging trashed ciphers");
|
|
|
|
debug!("Purging trashed ciphers");
|
|
|
|
if let Ok(conn) = pool.get().await {
|
|
|
|
if let Ok(mut conn) = pool.get().await {
|
|
|
|
Cipher::purge_trash(&conn).await;
|
|
|
|
Cipher::purge_trash(&mut conn).await;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
error!("Failed to get DB connection while purging trashed ciphers")
|
|
|
|
error!("Failed to get DB connection while purging trashed ciphers")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -99,39 +98,33 @@ struct SyncData {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[get("/sync?<data..>")]
|
|
|
|
#[get("/sync?<data..>")]
|
|
|
|
async fn sync(data: SyncData, headers: Headers, conn: DbConn) -> Json<Value> {
|
|
|
|
async fn sync(data: SyncData, headers: Headers, mut conn: DbConn) -> Json<Value> {
|
|
|
|
let user_json = headers.user.to_json(&conn).await;
|
|
|
|
let user_json = headers.user.to_json(&mut conn).await;
|
|
|
|
|
|
|
|
|
|
|
|
// Get all ciphers which are visible by the user
|
|
|
|
// Get all ciphers which are visible by the user
|
|
|
|
let ciphers = Cipher::find_by_user_visible(&headers.user.uuid, &conn).await;
|
|
|
|
let ciphers = Cipher::find_by_user_visible(&headers.user.uuid, &mut conn).await;
|
|
|
|
|
|
|
|
|
|
|
|
let cipher_sync_data = CipherSyncData::new(&headers.user.uuid, &ciphers, CipherSyncType::User, &conn).await;
|
|
|
|
let cipher_sync_data = CipherSyncData::new(&headers.user.uuid, &ciphers, CipherSyncType::User, &mut conn).await;
|
|
|
|
|
|
|
|
|
|
|
|
// Lets generate the ciphers_json using all the gathered info
|
|
|
|
// Lets generate the ciphers_json using all the gathered info
|
|
|
|
let ciphers_json: Vec<Value> = stream::iter(ciphers)
|
|
|
|
let mut ciphers_json = Vec::new();
|
|
|
|
.then(|c| async {
|
|
|
|
for c in ciphers {
|
|
|
|
let c = c; // Move out this single variable
|
|
|
|
ciphers_json.push(c.to_json(&headers.host, &headers.user.uuid, Some(&cipher_sync_data), &mut conn).await);
|
|
|
|
c.to_json(&headers.host, &headers.user.uuid, Some(&cipher_sync_data), &conn).await
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
.collect()
|
|
|
|
let mut collections_json = Vec::new();
|
|
|
|
.await;
|
|
|
|
for c in Collection::find_by_user_uuid(headers.user.uuid.clone(), &mut conn).await {
|
|
|
|
|
|
|
|
collections_json.push(c.to_json_details(&headers.user.uuid, Some(&cipher_sync_data), &mut conn).await);
|
|
|
|
let collections_json: Vec<Value> = stream::iter(Collection::find_by_user_uuid(&headers.user.uuid, &conn).await)
|
|
|
|
}
|
|
|
|
.then(|c| async {
|
|
|
|
|
|
|
|
let c = c; // Move out this single variable
|
|
|
|
|
|
|
|
c.to_json_details(&headers.user.uuid, Some(&cipher_sync_data), &conn).await
|
|
|
|
|
|
|
|
})
|
|
|
|
|
|
|
|
.collect()
|
|
|
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let folders_json: Vec<Value> =
|
|
|
|
let folders_json: Vec<Value> =
|
|
|
|
Folder::find_by_user(&headers.user.uuid, &conn).await.iter().map(Folder::to_json).collect();
|
|
|
|
Folder::find_by_user(&headers.user.uuid, &mut conn).await.iter().map(Folder::to_json).collect();
|
|
|
|
|
|
|
|
|
|
|
|
let sends_json: Vec<Value> =
|
|
|
|
let sends_json: Vec<Value> =
|
|
|
|
Send::find_by_user(&headers.user.uuid, &conn).await.iter().map(Send::to_json).collect();
|
|
|
|
Send::find_by_user(&headers.user.uuid, &mut conn).await.iter().map(Send::to_json).collect();
|
|
|
|
|
|
|
|
|
|
|
|
let policies_json: Vec<Value> =
|
|
|
|
let policies_json: Vec<Value> =
|
|
|
|
OrgPolicy::find_confirmed_by_user(&headers.user.uuid, &conn).await.iter().map(OrgPolicy::to_json).collect();
|
|
|
|
OrgPolicy::find_confirmed_by_user(&headers.user.uuid, &mut conn).await.iter().map(OrgPolicy::to_json).collect();
|
|
|
|
|
|
|
|
|
|
|
|
let domains_json = if data.exclude_domains {
|
|
|
|
let domains_json = if data.exclude_domains {
|
|
|
|
Value::Null
|
|
|
|
Value::Null
|
|
|
|
@ -153,17 +146,14 @@ async fn sync(data: SyncData, headers: Headers, conn: DbConn) -> Json<Value> {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[get("/ciphers")]
|
|
|
|
#[get("/ciphers")]
|
|
|
|
async fn get_ciphers(headers: Headers, conn: DbConn) -> Json<Value> {
|
|
|
|
async fn get_ciphers(headers: Headers, mut conn: DbConn) -> Json<Value> {
|
|
|
|
let ciphers = Cipher::find_by_user_visible(&headers.user.uuid, &conn).await;
|
|
|
|
let ciphers = Cipher::find_by_user_visible(&headers.user.uuid, &mut conn).await;
|
|
|
|
let cipher_sync_data = CipherSyncData::new(&headers.user.uuid, &ciphers, CipherSyncType::User, &conn).await;
|
|
|
|
let cipher_sync_data = CipherSyncData::new(&headers.user.uuid, &ciphers, CipherSyncType::User, &mut conn).await;
|
|
|
|
|
|
|
|
|
|
|
|
let ciphers_json = stream::iter(ciphers)
|
|
|
|
let mut ciphers_json = Vec::new();
|
|
|
|
.then(|c| async {
|
|
|
|
for c in ciphers {
|
|
|
|
let c = c; // Move out this single variable
|
|
|
|
ciphers_json.push(c.to_json(&headers.host, &headers.user.uuid, Some(&cipher_sync_data), &mut conn).await);
|
|
|
|
c.to_json(&headers.host, &headers.user.uuid, Some(&cipher_sync_data), &conn).await
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
.collect::<Vec<Value>>()
|
|
|
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Json(json!({
|
|
|
|
Json(json!({
|
|
|
|
"Data": ciphers_json,
|
|
|
|
"Data": ciphers_json,
|
|
|
|
@ -173,17 +163,17 @@ async fn get_ciphers(headers: Headers, conn: DbConn) -> Json<Value> {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[get("/ciphers/<uuid>")]
|
|
|
|
#[get("/ciphers/<uuid>")]
|
|
|
|
async fn get_cipher(uuid: String, headers: Headers, conn: DbConn) -> JsonResult {
|
|
|
|
async fn get_cipher(uuid: String, headers: Headers, mut conn: DbConn) -> JsonResult {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &conn).await {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &mut conn).await {
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if !cipher.is_accessible_to_user(&headers.user.uuid, &conn).await {
|
|
|
|
if !cipher.is_accessible_to_user(&headers.user.uuid, &mut conn).await {
|
|
|
|
err!("Cipher is not owned by user")
|
|
|
|
err!("Cipher is not owned by user")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &conn).await))
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &mut conn).await))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[get("/ciphers/<uuid>/admin")]
|
|
|
|
#[get("/ciphers/<uuid>/admin")]
|
|
|
|
@ -269,7 +259,7 @@ async fn post_ciphers_admin(
|
|
|
|
async fn post_ciphers_create(
|
|
|
|
async fn post_ciphers_create(
|
|
|
|
data: JsonUpcase<ShareCipherData>,
|
|
|
|
data: JsonUpcase<ShareCipherData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
let mut data: ShareCipherData = data.into_inner().data;
|
|
|
|
let mut data: ShareCipherData = data.into_inner().data;
|
|
|
|
@ -283,11 +273,11 @@ async fn post_ciphers_create(
|
|
|
|
// This check is usually only needed in update_cipher_from_data(), but we
|
|
|
|
// This check is usually only needed in update_cipher_from_data(), but we
|
|
|
|
// need it here as well to avoid creating an empty cipher in the call to
|
|
|
|
// need it here as well to avoid creating an empty cipher in the call to
|
|
|
|
// cipher.save() below.
|
|
|
|
// cipher.save() below.
|
|
|
|
enforce_personal_ownership_policy(Some(&data.Cipher), &headers, &conn).await?;
|
|
|
|
enforce_personal_ownership_policy(Some(&data.Cipher), &headers, &mut conn).await?;
|
|
|
|
|
|
|
|
|
|
|
|
let mut cipher = Cipher::new(data.Cipher.Type, data.Cipher.Name.clone());
|
|
|
|
let mut cipher = Cipher::new(data.Cipher.Type, data.Cipher.Name.clone());
|
|
|
|
cipher.user_uuid = Some(headers.user.uuid.clone());
|
|
|
|
cipher.user_uuid = Some(headers.user.uuid.clone());
|
|
|
|
cipher.save(&conn).await?;
|
|
|
|
cipher.save(&mut conn).await?;
|
|
|
|
|
|
|
|
|
|
|
|
// When cloning a cipher, the Bitwarden clients seem to set this field
|
|
|
|
// When cloning a cipher, the Bitwarden clients seem to set this field
|
|
|
|
// based on the cipher being cloned (when creating a new cipher, it's set
|
|
|
|
// based on the cipher being cloned (when creating a new cipher, it's set
|
|
|
|
@ -297,12 +287,12 @@ async fn post_ciphers_create(
|
|
|
|
// or otherwise), we can just ignore this field entirely.
|
|
|
|
// or otherwise), we can just ignore this field entirely.
|
|
|
|
data.Cipher.LastKnownRevisionDate = None;
|
|
|
|
data.Cipher.LastKnownRevisionDate = None;
|
|
|
|
|
|
|
|
|
|
|
|
share_cipher_by_uuid(&cipher.uuid, data, &headers, &conn, &nt).await
|
|
|
|
share_cipher_by_uuid(&cipher.uuid, data, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Called when creating a new user-owned cipher.
|
|
|
|
/// Called when creating a new user-owned cipher.
|
|
|
|
#[post("/ciphers", data = "<data>")]
|
|
|
|
#[post("/ciphers", data = "<data>")]
|
|
|
|
async fn post_ciphers(data: JsonUpcase<CipherData>, headers: Headers, conn: DbConn, nt: Notify<'_>) -> JsonResult {
|
|
|
|
async fn post_ciphers(data: JsonUpcase<CipherData>, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> JsonResult {
|
|
|
|
let mut data: CipherData = data.into_inner().data;
|
|
|
|
let mut data: CipherData = data.into_inner().data;
|
|
|
|
|
|
|
|
|
|
|
|
// The web/browser clients set this field to null as expected, but the
|
|
|
|
// The web/browser clients set this field to null as expected, but the
|
|
|
|
@ -312,9 +302,9 @@ async fn post_ciphers(data: JsonUpcase<CipherData>, headers: Headers, conn: DbCo
|
|
|
|
data.LastKnownRevisionDate = None;
|
|
|
|
data.LastKnownRevisionDate = None;
|
|
|
|
|
|
|
|
|
|
|
|
let mut cipher = Cipher::new(data.Type, data.Name.clone());
|
|
|
|
let mut cipher = Cipher::new(data.Type, data.Name.clone());
|
|
|
|
update_cipher_from_data(&mut cipher, data, &headers, false, &conn, &nt, UpdateType::CipherCreate).await?;
|
|
|
|
update_cipher_from_data(&mut cipher, data, &headers, false, &mut conn, &nt, UpdateType::CipherCreate).await?;
|
|
|
|
|
|
|
|
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &conn).await))
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &mut conn).await))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// Enforces the personal ownership policy on user-owned ciphers, if applicable.
|
|
|
|
/// Enforces the personal ownership policy on user-owned ciphers, if applicable.
|
|
|
|
@ -324,7 +314,11 @@ async fn post_ciphers(data: JsonUpcase<CipherData>, headers: Headers, conn: DbCo
|
|
|
|
/// allowed to delete or share such ciphers to an org, however.
|
|
|
|
/// allowed to delete or share such ciphers to an org, however.
|
|
|
|
///
|
|
|
|
///
|
|
|
|
/// Ref: https://bitwarden.com/help/article/policies/#personal-ownership
|
|
|
|
/// Ref: https://bitwarden.com/help/article/policies/#personal-ownership
|
|
|
|
async fn enforce_personal_ownership_policy(data: Option<&CipherData>, headers: &Headers, conn: &DbConn) -> EmptyResult {
|
|
|
|
async fn enforce_personal_ownership_policy(
|
|
|
|
|
|
|
|
data: Option<&CipherData>,
|
|
|
|
|
|
|
|
headers: &Headers,
|
|
|
|
|
|
|
|
conn: &mut DbConn,
|
|
|
|
|
|
|
|
) -> EmptyResult {
|
|
|
|
if data.is_none() || data.unwrap().OrganizationId.is_none() {
|
|
|
|
if data.is_none() || data.unwrap().OrganizationId.is_none() {
|
|
|
|
let user_uuid = &headers.user.uuid;
|
|
|
|
let user_uuid = &headers.user.uuid;
|
|
|
|
let policy_type = OrgPolicyType::PersonalOwnership;
|
|
|
|
let policy_type = OrgPolicyType::PersonalOwnership;
|
|
|
|
@ -340,7 +334,7 @@ pub async fn update_cipher_from_data(
|
|
|
|
data: CipherData,
|
|
|
|
data: CipherData,
|
|
|
|
headers: &Headers,
|
|
|
|
headers: &Headers,
|
|
|
|
shared_to_collection: bool,
|
|
|
|
shared_to_collection: bool,
|
|
|
|
conn: &DbConn,
|
|
|
|
conn: &mut DbConn,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
ut: UpdateType,
|
|
|
|
ut: UpdateType,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
@ -493,10 +487,10 @@ struct RelationsData {
|
|
|
|
async fn post_ciphers_import(
|
|
|
|
async fn post_ciphers_import(
|
|
|
|
data: JsonUpcase<ImportData>,
|
|
|
|
data: JsonUpcase<ImportData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
enforce_personal_ownership_policy(None, &headers, &conn).await?;
|
|
|
|
enforce_personal_ownership_policy(None, &headers, &mut conn).await?;
|
|
|
|
|
|
|
|
|
|
|
|
let data: ImportData = data.into_inner().data;
|
|
|
|
let data: ImportData = data.into_inner().data;
|
|
|
|
|
|
|
|
|
|
|
|
@ -504,7 +498,7 @@ async fn post_ciphers_import(
|
|
|
|
let mut folders: Vec<_> = Vec::new();
|
|
|
|
let mut folders: Vec<_> = Vec::new();
|
|
|
|
for folder in data.Folders.into_iter() {
|
|
|
|
for folder in data.Folders.into_iter() {
|
|
|
|
let mut new_folder = Folder::new(headers.user.uuid.clone(), folder.Name);
|
|
|
|
let mut new_folder = Folder::new(headers.user.uuid.clone(), folder.Name);
|
|
|
|
new_folder.save(&conn).await?;
|
|
|
|
new_folder.save(&mut conn).await?;
|
|
|
|
|
|
|
|
|
|
|
|
folders.push(new_folder);
|
|
|
|
folders.push(new_folder);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -522,11 +516,11 @@ async fn post_ciphers_import(
|
|
|
|
cipher_data.FolderId = folder_uuid;
|
|
|
|
cipher_data.FolderId = folder_uuid;
|
|
|
|
|
|
|
|
|
|
|
|
let mut cipher = Cipher::new(cipher_data.Type, cipher_data.Name.clone());
|
|
|
|
let mut cipher = Cipher::new(cipher_data.Type, cipher_data.Name.clone());
|
|
|
|
update_cipher_from_data(&mut cipher, cipher_data, &headers, false, &conn, &nt, UpdateType::None).await?;
|
|
|
|
update_cipher_from_data(&mut cipher, cipher_data, &headers, false, &mut conn, &nt, UpdateType::None).await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
let mut user = headers.user;
|
|
|
|
let mut user = headers.user;
|
|
|
|
user.update_revision(&conn).await?;
|
|
|
|
user.update_revision(&mut conn).await?;
|
|
|
|
nt.send_user_update(UpdateType::Vault, &user).await;
|
|
|
|
nt.send_user_update(UpdateType::Vault, &user).await;
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -570,12 +564,12 @@ async fn put_cipher(
|
|
|
|
uuid: String,
|
|
|
|
uuid: String,
|
|
|
|
data: JsonUpcase<CipherData>,
|
|
|
|
data: JsonUpcase<CipherData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
let data: CipherData = data.into_inner().data;
|
|
|
|
let data: CipherData = data.into_inner().data;
|
|
|
|
|
|
|
|
|
|
|
|
let mut cipher = match Cipher::find_by_uuid(&uuid, &conn).await {
|
|
|
|
let mut cipher = match Cipher::find_by_uuid(&uuid, &mut conn).await {
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
};
|
|
|
|
};
|
|
|
|
@ -585,13 +579,13 @@ async fn put_cipher(
|
|
|
|
// cipher itself, so the user shouldn't need write access to change these.
|
|
|
|
// cipher itself, so the user shouldn't need write access to change these.
|
|
|
|
// Interestingly, upstream Bitwarden doesn't properly handle this either.
|
|
|
|
// Interestingly, upstream Bitwarden doesn't properly handle this either.
|
|
|
|
|
|
|
|
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &conn).await {
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &mut conn).await {
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
update_cipher_from_data(&mut cipher, data, &headers, false, &conn, &nt, UpdateType::CipherUpdate).await?;
|
|
|
|
update_cipher_from_data(&mut cipher, data, &headers, false, &mut conn, &nt, UpdateType::CipherUpdate).await?;
|
|
|
|
|
|
|
|
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &conn).await))
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &mut conn).await))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
@ -635,34 +629,34 @@ async fn post_collections_admin(
|
|
|
|
uuid: String,
|
|
|
|
uuid: String,
|
|
|
|
data: JsonUpcase<CollectionsAdminData>,
|
|
|
|
data: JsonUpcase<CollectionsAdminData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
let data: CollectionsAdminData = data.into_inner().data;
|
|
|
|
let data: CollectionsAdminData = data.into_inner().data;
|
|
|
|
|
|
|
|
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &conn).await {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &mut conn).await {
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &conn).await {
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &mut conn).await {
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
let posted_collections: HashSet<String> = data.CollectionIds.iter().cloned().collect();
|
|
|
|
let posted_collections: HashSet<String> = data.CollectionIds.iter().cloned().collect();
|
|
|
|
let current_collections: HashSet<String> =
|
|
|
|
let current_collections: HashSet<String> =
|
|
|
|
cipher.get_collections(&headers.user.uuid, &conn).await.iter().cloned().collect();
|
|
|
|
cipher.get_collections(headers.user.uuid.clone(), &mut conn).await.iter().cloned().collect();
|
|
|
|
|
|
|
|
|
|
|
|
for collection in posted_collections.symmetric_difference(¤t_collections) {
|
|
|
|
for collection in posted_collections.symmetric_difference(¤t_collections) {
|
|
|
|
match Collection::find_by_uuid(collection, &conn).await {
|
|
|
|
match Collection::find_by_uuid(collection, &mut conn).await {
|
|
|
|
None => err!("Invalid collection ID provided"),
|
|
|
|
None => err!("Invalid collection ID provided"),
|
|
|
|
Some(collection) => {
|
|
|
|
Some(collection) => {
|
|
|
|
if collection.is_writable_by_user(&headers.user.uuid, &conn).await {
|
|
|
|
if collection.is_writable_by_user(&headers.user.uuid, &mut conn).await {
|
|
|
|
if posted_collections.contains(&collection.uuid) {
|
|
|
|
if posted_collections.contains(&collection.uuid) {
|
|
|
|
// Add to collection
|
|
|
|
// Add to collection
|
|
|
|
CollectionCipher::save(&cipher.uuid, &collection.uuid, &conn).await?;
|
|
|
|
CollectionCipher::save(&cipher.uuid, &collection.uuid, &mut conn).await?;
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
// Remove from collection
|
|
|
|
// Remove from collection
|
|
|
|
CollectionCipher::delete(&cipher.uuid, &collection.uuid, &conn).await?;
|
|
|
|
CollectionCipher::delete(&cipher.uuid, &collection.uuid, &mut conn).await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
err!("No rights to modify the collection")
|
|
|
|
err!("No rights to modify the collection")
|
|
|
|
@ -686,12 +680,12 @@ async fn post_cipher_share(
|
|
|
|
uuid: String,
|
|
|
|
uuid: String,
|
|
|
|
data: JsonUpcase<ShareCipherData>,
|
|
|
|
data: JsonUpcase<ShareCipherData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
let data: ShareCipherData = data.into_inner().data;
|
|
|
|
let data: ShareCipherData = data.into_inner().data;
|
|
|
|
|
|
|
|
|
|
|
|
share_cipher_by_uuid(&uuid, data, &headers, &conn, &nt).await
|
|
|
|
share_cipher_by_uuid(&uuid, data, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[put("/ciphers/<uuid>/share", data = "<data>")]
|
|
|
|
#[put("/ciphers/<uuid>/share", data = "<data>")]
|
|
|
|
@ -699,12 +693,12 @@ async fn put_cipher_share(
|
|
|
|
uuid: String,
|
|
|
|
uuid: String,
|
|
|
|
data: JsonUpcase<ShareCipherData>,
|
|
|
|
data: JsonUpcase<ShareCipherData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
let data: ShareCipherData = data.into_inner().data;
|
|
|
|
let data: ShareCipherData = data.into_inner().data;
|
|
|
|
|
|
|
|
|
|
|
|
share_cipher_by_uuid(&uuid, data, &headers, &conn, &nt).await
|
|
|
|
share_cipher_by_uuid(&uuid, data, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
@ -718,7 +712,7 @@ struct ShareSelectedCipherData {
|
|
|
|
async fn put_cipher_share_selected(
|
|
|
|
async fn put_cipher_share_selected(
|
|
|
|
data: JsonUpcase<ShareSelectedCipherData>,
|
|
|
|
data: JsonUpcase<ShareSelectedCipherData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
let mut data: ShareSelectedCipherData = data.into_inner().data;
|
|
|
|
let mut data: ShareSelectedCipherData = data.into_inner().data;
|
|
|
|
@ -746,7 +740,7 @@ async fn put_cipher_share_selected(
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
match shared_cipher_data.Cipher.Id.take() {
|
|
|
|
match shared_cipher_data.Cipher.Id.take() {
|
|
|
|
Some(id) => share_cipher_by_uuid(&id, shared_cipher_data, &headers, &conn, &nt).await?,
|
|
|
|
Some(id) => share_cipher_by_uuid(&id, shared_cipher_data, &headers, &mut conn, &nt).await?,
|
|
|
|
None => err!("Request missing ids field"),
|
|
|
|
None => err!("Request missing ids field"),
|
|
|
|
};
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -758,7 +752,7 @@ async fn share_cipher_by_uuid(
|
|
|
|
uuid: &str,
|
|
|
|
uuid: &str,
|
|
|
|
data: ShareCipherData,
|
|
|
|
data: ShareCipherData,
|
|
|
|
headers: &Headers,
|
|
|
|
headers: &Headers,
|
|
|
|
conn: &DbConn,
|
|
|
|
conn: &mut DbConn,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
let mut cipher = match Cipher::find_by_uuid(uuid, conn).await {
|
|
|
|
let mut cipher = match Cipher::find_by_uuid(uuid, conn).await {
|
|
|
|
@ -816,8 +810,8 @@ async fn share_cipher_by_uuid(
|
|
|
|
/// their object storage service. For self-hosted instances, it basically just
|
|
|
|
/// their object storage service. For self-hosted instances, it basically just
|
|
|
|
/// redirects to the same location as before the v2 API.
|
|
|
|
/// redirects to the same location as before the v2 API.
|
|
|
|
#[get("/ciphers/<uuid>/attachment/<attachment_id>")]
|
|
|
|
#[get("/ciphers/<uuid>/attachment/<attachment_id>")]
|
|
|
|
async fn get_attachment(uuid: String, attachment_id: String, headers: Headers, conn: DbConn) -> JsonResult {
|
|
|
|
async fn get_attachment(uuid: String, attachment_id: String, headers: Headers, mut conn: DbConn) -> JsonResult {
|
|
|
|
match Attachment::find_by_id(&attachment_id, &conn).await {
|
|
|
|
match Attachment::find_by_id(&attachment_id, &mut conn).await {
|
|
|
|
Some(attachment) if uuid == attachment.cipher_uuid => Ok(Json(attachment.to_json(&headers.host))),
|
|
|
|
Some(attachment) if uuid == attachment.cipher_uuid => Ok(Json(attachment.to_json(&headers.host))),
|
|
|
|
Some(_) => err!("Attachment doesn't belong to cipher"),
|
|
|
|
Some(_) => err!("Attachment doesn't belong to cipher"),
|
|
|
|
None => err!("Attachment doesn't exist"),
|
|
|
|
None => err!("Attachment doesn't exist"),
|
|
|
|
@ -847,14 +841,14 @@ async fn post_attachment_v2(
|
|
|
|
uuid: String,
|
|
|
|
uuid: String,
|
|
|
|
data: JsonUpcase<AttachmentRequestData>,
|
|
|
|
data: JsonUpcase<AttachmentRequestData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &conn).await {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &mut conn).await {
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &conn).await {
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &mut conn).await {
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -862,7 +856,7 @@ async fn post_attachment_v2(
|
|
|
|
let data: AttachmentRequestData = data.into_inner().data;
|
|
|
|
let data: AttachmentRequestData = data.into_inner().data;
|
|
|
|
let attachment =
|
|
|
|
let attachment =
|
|
|
|
Attachment::new(attachment_id.clone(), cipher.uuid.clone(), data.FileName, data.FileSize, Some(data.Key));
|
|
|
|
Attachment::new(attachment_id.clone(), cipher.uuid.clone(), data.FileName, data.FileSize, Some(data.Key));
|
|
|
|
attachment.save(&conn).await.expect("Error saving attachment");
|
|
|
|
attachment.save(&mut conn).await.expect("Error saving attachment");
|
|
|
|
|
|
|
|
|
|
|
|
let url = format!("/ciphers/{}/attachment/{}", cipher.uuid, attachment_id);
|
|
|
|
let url = format!("/ciphers/{}/attachment/{}", cipher.uuid, attachment_id);
|
|
|
|
let response_key = match data.AdminRequest {
|
|
|
|
let response_key = match data.AdminRequest {
|
|
|
|
@ -875,7 +869,7 @@ async fn post_attachment_v2(
|
|
|
|
"AttachmentId": attachment_id,
|
|
|
|
"AttachmentId": attachment_id,
|
|
|
|
"Url": url,
|
|
|
|
"Url": url,
|
|
|
|
"FileUploadType": FileUploadType::Direct as i32,
|
|
|
|
"FileUploadType": FileUploadType::Direct as i32,
|
|
|
|
response_key: cipher.to_json(&headers.host, &headers.user.uuid, None, &conn).await,
|
|
|
|
response_key: cipher.to_json(&headers.host, &headers.user.uuid, None, &mut conn).await,
|
|
|
|
})))
|
|
|
|
})))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -898,15 +892,15 @@ async fn save_attachment(
|
|
|
|
cipher_uuid: String,
|
|
|
|
cipher_uuid: String,
|
|
|
|
data: Form<UploadData<'_>>,
|
|
|
|
data: Form<UploadData<'_>>,
|
|
|
|
headers: &Headers,
|
|
|
|
headers: &Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> Result<(Cipher, DbConn), crate::error::Error> {
|
|
|
|
) -> Result<(Cipher, DbConn), crate::error::Error> {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&cipher_uuid, &conn).await {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&cipher_uuid, &mut conn).await {
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &conn).await {
|
|
|
|
if !cipher.is_write_accessible_to_user(&headers.user.uuid, &mut conn).await {
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
err!("Cipher is not write accessible")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -921,7 +915,7 @@ async fn save_attachment(
|
|
|
|
match CONFIG.user_attachment_limit() {
|
|
|
|
match CONFIG.user_attachment_limit() {
|
|
|
|
Some(0) => err!("Attachments are disabled"),
|
|
|
|
Some(0) => err!("Attachments are disabled"),
|
|
|
|
Some(limit_kb) => {
|
|
|
|
Some(limit_kb) => {
|
|
|
|
let left = (limit_kb * 1024) - Attachment::size_by_user(user_uuid, &conn).await + size_adjust;
|
|
|
|
let left = (limit_kb * 1024) - Attachment::size_by_user(user_uuid, &mut conn).await + size_adjust;
|
|
|
|
if left <= 0 {
|
|
|
|
if left <= 0 {
|
|
|
|
err!("Attachment storage limit reached! Delete some attachments to free up space")
|
|
|
|
err!("Attachment storage limit reached! Delete some attachments to free up space")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -933,7 +927,7 @@ async fn save_attachment(
|
|
|
|
match CONFIG.org_attachment_limit() {
|
|
|
|
match CONFIG.org_attachment_limit() {
|
|
|
|
Some(0) => err!("Attachments are disabled"),
|
|
|
|
Some(0) => err!("Attachments are disabled"),
|
|
|
|
Some(limit_kb) => {
|
|
|
|
Some(limit_kb) => {
|
|
|
|
let left = (limit_kb * 1024) - Attachment::size_by_org(org_uuid, &conn).await + size_adjust;
|
|
|
|
let left = (limit_kb * 1024) - Attachment::size_by_org(org_uuid, &mut conn).await + size_adjust;
|
|
|
|
if left <= 0 {
|
|
|
|
if left <= 0 {
|
|
|
|
err!("Attachment storage limit reached! Delete some attachments to free up space")
|
|
|
|
err!("Attachment storage limit reached! Delete some attachments to free up space")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -990,10 +984,10 @@ async fn save_attachment(
|
|
|
|
if size != attachment.file_size {
|
|
|
|
if size != attachment.file_size {
|
|
|
|
// Update the attachment with the actual file size.
|
|
|
|
// Update the attachment with the actual file size.
|
|
|
|
attachment.file_size = size;
|
|
|
|
attachment.file_size = size;
|
|
|
|
attachment.save(&conn).await.expect("Error updating attachment");
|
|
|
|
attachment.save(&mut conn).await.expect("Error updating attachment");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
attachment.delete(&conn).await.ok();
|
|
|
|
attachment.delete(&mut conn).await.ok();
|
|
|
|
|
|
|
|
|
|
|
|
err!(format!("Attachment size mismatch (expected within [{}, {}], got {})", min_size, max_size, size));
|
|
|
|
err!(format!("Attachment size mismatch (expected within [{}, {}], got {})", min_size, max_size, size));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1008,14 +1002,14 @@ async fn save_attachment(
|
|
|
|
err!("No attachment key provided")
|
|
|
|
err!("No attachment key provided")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
let attachment = Attachment::new(file_id, cipher_uuid.clone(), encrypted_filename.unwrap(), size, data.key);
|
|
|
|
let attachment = Attachment::new(file_id, cipher_uuid.clone(), encrypted_filename.unwrap(), size, data.key);
|
|
|
|
attachment.save(&conn).await.expect("Error saving attachment");
|
|
|
|
attachment.save(&mut conn).await.expect("Error saving attachment");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if let Err(_err) = data.data.persist_to(&file_path).await {
|
|
|
|
if let Err(_err) = data.data.persist_to(&file_path).await {
|
|
|
|
data.data.move_copy_to(file_path).await?
|
|
|
|
data.data.move_copy_to(file_path).await?
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nt.send_cipher_update(UpdateType::CipherUpdate, &cipher, &cipher.update_users_revision(&conn).await).await;
|
|
|
|
nt.send_cipher_update(UpdateType::CipherUpdate, &cipher, &cipher.update_users_revision(&mut conn).await).await;
|
|
|
|
|
|
|
|
|
|
|
|
Ok((cipher, conn))
|
|
|
|
Ok((cipher, conn))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1030,10 +1024,10 @@ async fn post_attachment_v2_data(
|
|
|
|
attachment_id: String,
|
|
|
|
attachment_id: String,
|
|
|
|
data: Form<UploadData<'_>>,
|
|
|
|
data: Form<UploadData<'_>>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
let attachment = match Attachment::find_by_id(&attachment_id, &conn).await {
|
|
|
|
let attachment = match Attachment::find_by_id(&attachment_id, &mut conn).await {
|
|
|
|
Some(attachment) if uuid == attachment.cipher_uuid => Some(attachment),
|
|
|
|
Some(attachment) if uuid == attachment.cipher_uuid => Some(attachment),
|
|
|
|
Some(_) => err!("Attachment doesn't belong to cipher"),
|
|
|
|
Some(_) => err!("Attachment doesn't belong to cipher"),
|
|
|
|
None => err!("Attachment doesn't exist"),
|
|
|
|
None => err!("Attachment doesn't exist"),
|
|
|
|
@ -1057,9 +1051,9 @@ async fn post_attachment(
|
|
|
|
// the attachment database record as well as saving the data to disk.
|
|
|
|
// the attachment database record as well as saving the data to disk.
|
|
|
|
let attachment = None;
|
|
|
|
let attachment = None;
|
|
|
|
|
|
|
|
|
|
|
|
let (cipher, conn) = save_attachment(attachment, uuid, data, &headers, conn, nt).await?;
|
|
|
|
let (cipher, mut conn) = save_attachment(attachment, uuid, data, &headers, conn, nt).await?;
|
|
|
|
|
|
|
|
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &conn).await))
|
|
|
|
Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, None, &mut conn).await))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[post("/ciphers/<uuid>/attachment-admin", format = "multipart/form-data", data = "<data>")]
|
|
|
|
#[post("/ciphers/<uuid>/attachment-admin", format = "multipart/form-data", data = "<data>")]
|
|
|
|
@ -1079,10 +1073,10 @@ async fn post_attachment_share(
|
|
|
|
attachment_id: String,
|
|
|
|
attachment_id: String,
|
|
|
|
data: Form<UploadData<'_>>,
|
|
|
|
data: Form<UploadData<'_>>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
_delete_cipher_attachment_by_id(&uuid, &attachment_id, &headers, &conn, &nt).await?;
|
|
|
|
_delete_cipher_attachment_by_id(&uuid, &attachment_id, &headers, &mut conn, &nt).await?;
|
|
|
|
post_attachment(uuid, data, headers, conn, nt).await
|
|
|
|
post_attachment(uuid, data, headers, conn, nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@ -1113,10 +1107,10 @@ async fn delete_attachment(
|
|
|
|
uuid: String,
|
|
|
|
uuid: String,
|
|
|
|
attachment_id: String,
|
|
|
|
attachment_id: String,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
_delete_cipher_attachment_by_id(&uuid, &attachment_id, &headers, &conn, &nt).await
|
|
|
|
_delete_cipher_attachment_by_id(&uuid, &attachment_id, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[delete("/ciphers/<uuid>/attachment/<attachment_id>/admin")]
|
|
|
|
#[delete("/ciphers/<uuid>/attachment/<attachment_id>/admin")]
|
|
|
|
@ -1124,40 +1118,40 @@ async fn delete_attachment_admin(
|
|
|
|
uuid: String,
|
|
|
|
uuid: String,
|
|
|
|
attachment_id: String,
|
|
|
|
attachment_id: String,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
_delete_cipher_attachment_by_id(&uuid, &attachment_id, &headers, &conn, &nt).await
|
|
|
|
_delete_cipher_attachment_by_id(&uuid, &attachment_id, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[post("/ciphers/<uuid>/delete")]
|
|
|
|
#[post("/ciphers/<uuid>/delete")]
|
|
|
|
async fn delete_cipher_post(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
async fn delete_cipher_post(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &conn, false, &nt).await
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &mut conn, false, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[post("/ciphers/<uuid>/delete-admin")]
|
|
|
|
#[post("/ciphers/<uuid>/delete-admin")]
|
|
|
|
async fn delete_cipher_post_admin(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
async fn delete_cipher_post_admin(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &conn, false, &nt).await
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &mut conn, false, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[put("/ciphers/<uuid>/delete")]
|
|
|
|
#[put("/ciphers/<uuid>/delete")]
|
|
|
|
async fn delete_cipher_put(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
async fn delete_cipher_put(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &conn, true, &nt).await
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &mut conn, true, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[put("/ciphers/<uuid>/delete-admin")]
|
|
|
|
#[put("/ciphers/<uuid>/delete-admin")]
|
|
|
|
async fn delete_cipher_put_admin(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
async fn delete_cipher_put_admin(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &conn, true, &nt).await
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &mut conn, true, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[delete("/ciphers/<uuid>")]
|
|
|
|
#[delete("/ciphers/<uuid>")]
|
|
|
|
async fn delete_cipher(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
async fn delete_cipher(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &conn, false, &nt).await
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &mut conn, false, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[delete("/ciphers/<uuid>/admin")]
|
|
|
|
#[delete("/ciphers/<uuid>/admin")]
|
|
|
|
async fn delete_cipher_admin(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
async fn delete_cipher_admin(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> EmptyResult {
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &conn, false, &nt).await
|
|
|
|
_delete_cipher_by_uuid(&uuid, &headers, &mut conn, false, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[delete("/ciphers", data = "<data>")]
|
|
|
|
#[delete("/ciphers", data = "<data>")]
|
|
|
|
@ -1221,23 +1215,23 @@ async fn delete_cipher_selected_put_admin(
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[put("/ciphers/<uuid>/restore")]
|
|
|
|
#[put("/ciphers/<uuid>/restore")]
|
|
|
|
async fn restore_cipher_put(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> JsonResult {
|
|
|
|
async fn restore_cipher_put(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> JsonResult {
|
|
|
|
_restore_cipher_by_uuid(&uuid, &headers, &conn, &nt).await
|
|
|
|
_restore_cipher_by_uuid(&uuid, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[put("/ciphers/<uuid>/restore-admin")]
|
|
|
|
#[put("/ciphers/<uuid>/restore-admin")]
|
|
|
|
async fn restore_cipher_put_admin(uuid: String, headers: Headers, conn: DbConn, nt: Notify<'_>) -> JsonResult {
|
|
|
|
async fn restore_cipher_put_admin(uuid: String, headers: Headers, mut conn: DbConn, nt: Notify<'_>) -> JsonResult {
|
|
|
|
_restore_cipher_by_uuid(&uuid, &headers, &conn, &nt).await
|
|
|
|
_restore_cipher_by_uuid(&uuid, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[put("/ciphers/restore", data = "<data>")]
|
|
|
|
#[put("/ciphers/restore", data = "<data>")]
|
|
|
|
async fn restore_cipher_selected(
|
|
|
|
async fn restore_cipher_selected(
|
|
|
|
data: JsonUpcase<Value>,
|
|
|
|
data: JsonUpcase<Value>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
_restore_multiple_ciphers(data, &headers, &conn, &nt).await
|
|
|
|
_restore_multiple_ciphers(data, &headers, &mut conn, &nt).await
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
@ -1251,14 +1245,14 @@ struct MoveCipherData {
|
|
|
|
async fn move_cipher_selected(
|
|
|
|
async fn move_cipher_selected(
|
|
|
|
data: JsonUpcase<MoveCipherData>,
|
|
|
|
data: JsonUpcase<MoveCipherData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
let data = data.into_inner().data;
|
|
|
|
let data = data.into_inner().data;
|
|
|
|
let user_uuid = headers.user.uuid;
|
|
|
|
let user_uuid = headers.user.uuid;
|
|
|
|
|
|
|
|
|
|
|
|
if let Some(ref folder_id) = data.FolderId {
|
|
|
|
if let Some(ref folder_id) = data.FolderId {
|
|
|
|
match Folder::find_by_uuid(folder_id, &conn).await {
|
|
|
|
match Folder::find_by_uuid(folder_id, &mut conn).await {
|
|
|
|
Some(folder) => {
|
|
|
|
Some(folder) => {
|
|
|
|
if folder.user_uuid != user_uuid {
|
|
|
|
if folder.user_uuid != user_uuid {
|
|
|
|
err!("Folder is not owned by user")
|
|
|
|
err!("Folder is not owned by user")
|
|
|
|
@ -1269,17 +1263,17 @@ async fn move_cipher_selected(
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
for uuid in data.Ids {
|
|
|
|
for uuid in data.Ids {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &conn).await {
|
|
|
|
let cipher = match Cipher::find_by_uuid(&uuid, &mut conn).await {
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
if !cipher.is_accessible_to_user(&user_uuid, &conn).await {
|
|
|
|
if !cipher.is_accessible_to_user(&user_uuid, &mut conn).await {
|
|
|
|
err!("Cipher is not accessible by user")
|
|
|
|
err!("Cipher is not accessible by user")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Move cipher
|
|
|
|
// Move cipher
|
|
|
|
cipher.move_to_folder(data.FolderId.clone(), &user_uuid, &conn).await?;
|
|
|
|
cipher.move_to_folder(data.FolderId.clone(), &user_uuid, &mut conn).await?;
|
|
|
|
|
|
|
|
|
|
|
|
nt.send_cipher_update(UpdateType::CipherUpdate, &cipher, &[user_uuid.clone()]).await;
|
|
|
|
nt.send_cipher_update(UpdateType::CipherUpdate, &cipher, &[user_uuid.clone()]).await;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1308,7 +1302,7 @@ async fn delete_all(
|
|
|
|
organization: Option<OrganizationId>,
|
|
|
|
organization: Option<OrganizationId>,
|
|
|
|
data: JsonUpcase<PasswordData>,
|
|
|
|
data: JsonUpcase<PasswordData>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
let data: PasswordData = data.into_inner().data;
|
|
|
|
let data: PasswordData = data.into_inner().data;
|
|
|
|
@ -1323,11 +1317,11 @@ async fn delete_all(
|
|
|
|
match organization {
|
|
|
|
match organization {
|
|
|
|
Some(org_data) => {
|
|
|
|
Some(org_data) => {
|
|
|
|
// Organization ID in query params, purging organization vault
|
|
|
|
// Organization ID in query params, purging organization vault
|
|
|
|
match UserOrganization::find_by_user_and_org(&user.uuid, &org_data.org_id, &conn).await {
|
|
|
|
match UserOrganization::find_by_user_and_org(&user.uuid, &org_data.org_id, &mut conn).await {
|
|
|
|
None => err!("You don't have permission to purge the organization vault"),
|
|
|
|
None => err!("You don't have permission to purge the organization vault"),
|
|
|
|
Some(user_org) => {
|
|
|
|
Some(user_org) => {
|
|
|
|
if user_org.atype == UserOrgType::Owner {
|
|
|
|
if user_org.atype == UserOrgType::Owner {
|
|
|
|
Cipher::delete_all_by_organization(&org_data.org_id, &conn).await?;
|
|
|
|
Cipher::delete_all_by_organization(&org_data.org_id, &mut conn).await?;
|
|
|
|
nt.send_user_update(UpdateType::Vault, &user).await;
|
|
|
|
nt.send_user_update(UpdateType::Vault, &user).await;
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
@ -1339,16 +1333,16 @@ async fn delete_all(
|
|
|
|
None => {
|
|
|
|
None => {
|
|
|
|
// No organization ID in query params, purging user vault
|
|
|
|
// No organization ID in query params, purging user vault
|
|
|
|
// Delete ciphers and their attachments
|
|
|
|
// Delete ciphers and their attachments
|
|
|
|
for cipher in Cipher::find_owned_by_user(&user.uuid, &conn).await {
|
|
|
|
for cipher in Cipher::find_owned_by_user(&user.uuid, &mut conn).await {
|
|
|
|
cipher.delete(&conn).await?;
|
|
|
|
cipher.delete(&mut conn).await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Delete folders
|
|
|
|
// Delete folders
|
|
|
|
for f in Folder::find_by_user(&user.uuid, &conn).await {
|
|
|
|
for f in Folder::find_by_user(&user.uuid, &mut conn).await {
|
|
|
|
f.delete(&conn).await?;
|
|
|
|
f.delete(&mut conn).await?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
user.update_revision(&conn).await?;
|
|
|
|
user.update_revision(&mut conn).await?;
|
|
|
|
nt.send_user_update(UpdateType::Vault, &user).await;
|
|
|
|
nt.send_user_update(UpdateType::Vault, &user).await;
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1358,7 +1352,7 @@ async fn delete_all(
|
|
|
|
async fn _delete_cipher_by_uuid(
|
|
|
|
async fn _delete_cipher_by_uuid(
|
|
|
|
uuid: &str,
|
|
|
|
uuid: &str,
|
|
|
|
headers: &Headers,
|
|
|
|
headers: &Headers,
|
|
|
|
conn: &DbConn,
|
|
|
|
conn: &mut DbConn,
|
|
|
|
soft_delete: bool,
|
|
|
|
soft_delete: bool,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
@ -1386,7 +1380,7 @@ async fn _delete_cipher_by_uuid(
|
|
|
|
async fn _delete_multiple_ciphers(
|
|
|
|
async fn _delete_multiple_ciphers(
|
|
|
|
data: JsonUpcase<Value>,
|
|
|
|
data: JsonUpcase<Value>,
|
|
|
|
headers: Headers,
|
|
|
|
headers: Headers,
|
|
|
|
conn: DbConn,
|
|
|
|
mut conn: DbConn,
|
|
|
|
soft_delete: bool,
|
|
|
|
soft_delete: bool,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
nt: Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
@ -1401,7 +1395,7 @@ async fn _delete_multiple_ciphers(
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
for uuid in uuids {
|
|
|
|
for uuid in uuids {
|
|
|
|
if let error @ Err(_) = _delete_cipher_by_uuid(uuid, &headers, &conn, soft_delete, &nt).await {
|
|
|
|
if let error @ Err(_) = _delete_cipher_by_uuid(uuid, &headers, &mut conn, soft_delete, &nt).await {
|
|
|
|
return error;
|
|
|
|
return error;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
@ -1409,7 +1403,7 @@ async fn _delete_multiple_ciphers(
|
|
|
|
Ok(())
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
async fn _restore_cipher_by_uuid(uuid: &str, headers: &Headers, conn: &DbConn, nt: &Notify<'_>) -> JsonResult {
|
|
|
|
async fn _restore_cipher_by_uuid(uuid: &str, headers: &Headers, conn: &mut DbConn, nt: &Notify<'_>) -> JsonResult {
|
|
|
|
let mut cipher = match Cipher::find_by_uuid(uuid, conn).await {
|
|
|
|
let mut cipher = match Cipher::find_by_uuid(uuid, conn).await {
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
Some(cipher) => cipher,
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
None => err!("Cipher doesn't exist"),
|
|
|
|
@ -1429,7 +1423,7 @@ async fn _restore_cipher_by_uuid(uuid: &str, headers: &Headers, conn: &DbConn, n
|
|
|
|
async fn _restore_multiple_ciphers(
|
|
|
|
async fn _restore_multiple_ciphers(
|
|
|
|
data: JsonUpcase<Value>,
|
|
|
|
data: JsonUpcase<Value>,
|
|
|
|
headers: &Headers,
|
|
|
|
headers: &Headers,
|
|
|
|
conn: &DbConn,
|
|
|
|
conn: &mut DbConn,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
) -> JsonResult {
|
|
|
|
) -> JsonResult {
|
|
|
|
let data: Value = data.into_inner().data;
|
|
|
|
let data: Value = data.into_inner().data;
|
|
|
|
@ -1461,7 +1455,7 @@ async fn _delete_cipher_attachment_by_id(
|
|
|
|
uuid: &str,
|
|
|
|
uuid: &str,
|
|
|
|
attachment_id: &str,
|
|
|
|
attachment_id: &str,
|
|
|
|
headers: &Headers,
|
|
|
|
headers: &Headers,
|
|
|
|
conn: &DbConn,
|
|
|
|
conn: &mut DbConn,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
nt: &Notify<'_>,
|
|
|
|
) -> EmptyResult {
|
|
|
|
) -> EmptyResult {
|
|
|
|
let attachment = match Attachment::find_by_id(attachment_id, conn).await {
|
|
|
|
let attachment = match Attachment::find_by_id(attachment_id, conn).await {
|
|
|
|
@ -1509,9 +1503,9 @@ pub enum CipherSyncType {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl CipherSyncData {
|
|
|
|
impl CipherSyncData {
|
|
|
|
pub async fn new(user_uuid: &str, ciphers: &Vec<Cipher>, sync_type: CipherSyncType, conn: &DbConn) -> Self {
|
|
|
|
pub async fn new(user_uuid: &str, ciphers: &[Cipher], sync_type: CipherSyncType, conn: &mut DbConn) -> Self {
|
|
|
|
// Generate a list of Cipher UUID's to be used during a query filter with an eq_any.
|
|
|
|
// Generate a list of Cipher UUID's to be used during a query filter with an eq_any.
|
|
|
|
let cipher_uuids = stream::iter(ciphers).map(|c| c.uuid.clone()).collect::<Vec<String>>().await;
|
|
|
|
let cipher_uuids = ciphers.iter().map(|c| c.uuid.clone()).collect();
|
|
|
|
|
|
|
|
|
|
|
|
let mut cipher_folders: HashMap<String, String> = HashMap::new();
|
|
|
|
let mut cipher_folders: HashMap<String, String> = HashMap::new();
|
|
|
|
let mut cipher_favorites: HashSet<String> = HashSet::new();
|
|
|
|
let mut cipher_favorites: HashSet<String> = HashSet::new();
|
|
|
|
@ -1519,11 +1513,10 @@ impl CipherSyncData {
|
|
|
|
// User Sync supports Folders and Favorits
|
|
|
|
// User Sync supports Folders and Favorits
|
|
|
|
CipherSyncType::User => {
|
|
|
|
CipherSyncType::User => {
|
|
|
|
// Generate a HashMap with the Cipher UUID as key and the Folder UUID as value
|
|
|
|
// Generate a HashMap with the Cipher UUID as key and the Folder UUID as value
|
|
|
|
cipher_folders = stream::iter(FolderCipher::find_by_user(user_uuid, conn).await).collect().await;
|
|
|
|
cipher_folders = FolderCipher::find_by_user(user_uuid, conn).await.into_iter().collect();
|
|
|
|
|
|
|
|
|
|
|
|
// Generate a HashSet of all the Cipher UUID's which are marked as favorite
|
|
|
|
// Generate a HashSet of all the Cipher UUID's which are marked as favorite
|
|
|
|
cipher_favorites =
|
|
|
|
cipher_favorites = Favorite::get_all_cipher_uuid_by_user(user_uuid, conn).await.into_iter().collect();
|
|
|
|
stream::iter(Favorite::get_all_cipher_uuid_by_user(user_uuid, conn).await).collect().await;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Organization Sync does not support Folders and Favorits.
|
|
|
|
// Organization Sync does not support Folders and Favorits.
|
|
|
|
// If these are set, it will cause issues in the web-vault.
|
|
|
|
// If these are set, it will cause issues in the web-vault.
|
|
|
|
@ -1538,33 +1531,34 @@ impl CipherSyncData {
|
|
|
|
|
|
|
|
|
|
|
|
// Generate a HashMap with the Cipher UUID as key and one or more Collection UUID's
|
|
|
|
// Generate a HashMap with the Cipher UUID as key and one or more Collection UUID's
|
|
|
|
let mut cipher_collections: HashMap<String, Vec<String>> = HashMap::new();
|
|
|
|
let mut cipher_collections: HashMap<String, Vec<String>> = HashMap::new();
|
|
|
|
for (cipher, collection) in Cipher::get_collections_with_cipher_by_user(user_uuid, conn).await {
|
|
|
|
for (cipher, collection) in Cipher::get_collections_with_cipher_by_user(user_uuid.to_string(), conn).await {
|
|
|
|
cipher_collections.entry(cipher).or_default().push(collection);
|
|
|
|
cipher_collections.entry(cipher).or_default().push(collection);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Generate a HashMap with the Organization UUID as key and the UserOrganization record
|
|
|
|
// Generate a HashMap with the Organization UUID as key and the UserOrganization record
|
|
|
|
let user_organizations: HashMap<String, UserOrganization> =
|
|
|
|
let user_organizations: HashMap<String, UserOrganization> = UserOrganization::find_by_user(user_uuid, conn)
|
|
|
|
stream::iter(UserOrganization::find_by_user(user_uuid, conn).await)
|
|
|
|
.await
|
|
|
|
.map(|uo| (uo.org_uuid.clone(), uo))
|
|
|
|
.into_iter()
|
|
|
|
.collect()
|
|
|
|
.map(|uo| (uo.org_uuid.clone(), uo))
|
|
|
|
.await;
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
|
|
|
|
// Generate a HashMap with the User_Collections UUID as key and the CollectionUser record
|
|
|
|
// Generate a HashMap with the User_Collections UUID as key and the CollectionUser record
|
|
|
|
let user_collections: HashMap<String, CollectionUser> =
|
|
|
|
let user_collections: HashMap<String, CollectionUser> = CollectionUser::find_by_user(user_uuid, conn)
|
|
|
|
stream::iter(CollectionUser::find_by_user(user_uuid, conn).await)
|
|
|
|
.await
|
|
|
|
.map(|uc| (uc.collection_uuid.clone(), uc))
|
|
|
|
.into_iter()
|
|
|
|
.collect()
|
|
|
|
.map(|uc| (uc.collection_uuid.clone(), uc))
|
|
|
|
.await;
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
|
|
|
|
// Generate a HashMap with the collections_uuid as key and the CollectionGroup record
|
|
|
|
// Generate a HashMap with the collections_uuid as key and the CollectionGroup record
|
|
|
|
let user_collections_groups = stream::iter(CollectionGroup::find_by_user(user_uuid, conn).await)
|
|
|
|
let user_collections_groups = CollectionGroup::find_by_user(user_uuid, conn)
|
|
|
|
|
|
|
|
.await
|
|
|
|
|
|
|
|
.into_iter()
|
|
|
|
.map(|collection_group| (collection_group.collections_uuid.clone(), collection_group))
|
|
|
|
.map(|collection_group| (collection_group.collections_uuid.clone(), collection_group))
|
|
|
|
.collect()
|
|
|
|
.collect();
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Get all organizations that the user has full access to via group assignement
|
|
|
|
// Get all organizations that the user has full access to via group assignement
|
|
|
|
let user_group_full_access_for_organizations =
|
|
|
|
let user_group_full_access_for_organizations =
|
|
|
|
stream::iter(Group::gather_user_organizations_full_access(user_uuid, conn).await).collect().await;
|
|
|
|
Group::gather_user_organizations_full_access(user_uuid, conn).await.into_iter().collect();
|
|
|
|
|
|
|
|
|
|
|
|
Self {
|
|
|
|
Self {
|
|
|
|
cipher_attachments,
|
|
|
|
cipher_attachments,
|
|
|
|
|
Daniel García
3 years ago