nickslowinski/vaultwarden-test
1
0
Fork 0
geforkt von mirrored/vaultwarden
Code Pull-Requests Aktivität

Merge pull request #1150 from BlackDex/mariadb-fk-issues

Quellcode durchsuchen 
Fixed foreign-key (mariadb) errors.
Dieser Commit ist enthalten in:
Daniel García 2020-09-27 16:24:34 +02:00 committet von GitHub
Commit 37776241be
Es konnte kein GPG-Schlüssel zu dieser Signatur gefunden werden
GPG-Schlüssel-ID: 4AEE18F83AFDEB23
8 geänderte Dateien mit 170 neuen und 45 gelöschten Zeilen
Statistiken anzeigen Patch-Datei herunterladen Diff-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

15
src/db/models/attachment.rs
Datei anzeigen

@ -63,10 +63,21 @@ impl Attachment {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(attachments::table) match diesel::replace_into(attachments::table)
.values(AttachmentDb::to_db(self)) .values(AttachmentDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving attachment") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(attachments::table)
.filter(attachments::id.eq(&self.id))
.set(AttachmentDb::to_db(self))
.execute(conn)
.map_res("Error saving attachment")
}
Err(e) => Err(e.into()),
}.map_res("Error saving attachment")
} }
postgresql { postgresql {
let value = AttachmentDb::to_db(self); let value = AttachmentDb::to_db(self);

21
src/db/models/cipher.rs
Datei anzeigen

@ -194,14 +194,25 @@ impl Cipher {
pub fn save(&mut self, conn: &DbConn) -> EmptyResult { pub fn save(&mut self, conn: &DbConn) -> EmptyResult {
self.update_users_revision(conn); self.update_users_revision(conn);
self.updated_at = Utc::now().naive_utc(); self.updated_at = Utc::now().naive_utc();
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(ciphers::table) match diesel::replace_into(ciphers::table)
.values(CipherDb::to_db(self)) .values(CipherDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving cipher") {
} Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(ciphers::table)
.filter(ciphers::uuid.eq(&self.uuid))
.set(CipherDb::to_db(self))
.execute(conn)
.map_res("Error saving cipher")
}
Err(e) => Err(e.into()),
}.map_res("Error saving cipher")
}
postgresql { postgresql {
let value = CipherDb::to_db(self); let value = CipherDb::to_db(self);
diesel::insert_into(ciphers::table) diesel::insert_into(ciphers::table)

49
src/db/models/collection.rs
Datei anzeigen

@ -67,12 +67,23 @@ impl Collection {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
self.update_users_revision(conn); self.update_users_revision(conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(collections::table) match diesel::replace_into(collections::table)
.values(CollectionDb::to_db(self)) .values(CollectionDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving collection") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(collections::table)
.filter(collections::uuid.eq(&self.uuid))
.set(CollectionDb::to_db(self))
.execute(conn)
.map_res("Error saving collection")
}
Err(e) => Err(e.into()),
}.map_res("Error saving collection")
} }
postgresql { postgresql {
let value = CollectionDb::to_db(self); let value = CollectionDb::to_db(self);
@ -82,7 +93,7 @@ impl Collection {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error saving collection") .map_res("Error saving collection")
} }
} }
} }
@ -245,9 +256,9 @@ impl CollectionUser {
pub fn save(user_uuid: &str, collection_uuid: &str, read_only: bool, hide_passwords: bool, conn: &DbConn) -> EmptyResult { pub fn save(user_uuid: &str, collection_uuid: &str, read_only: bool, hide_passwords: bool, conn: &DbConn) -> EmptyResult {
User::update_uuid_revision(&user_uuid, conn); User::update_uuid_revision(&user_uuid, conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(users_collections::table) match diesel::replace_into(users_collections::table)
.values(( .values((
users_collections::user_uuid.eq(user_uuid), users_collections::user_uuid.eq(user_uuid),
users_collections::collection_uuid.eq(collection_uuid), users_collections::collection_uuid.eq(collection_uuid),
@ -255,7 +266,24 @@ impl CollectionUser {
users_collections::hide_passwords.eq(hide_passwords), users_collections::hide_passwords.eq(hide_passwords),
)) ))
.execute(conn) .execute(conn)
.map_res("Error adding user to collection") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(users_collections::table)
.filter(users_collections::user_uuid.eq(user_uuid))
.filter(users_collections::collection_uuid.eq(collection_uuid))
.set((
users_collections::user_uuid.eq(user_uuid),
users_collections::collection_uuid.eq(collection_uuid),
users_collections::read_only.eq(read_only),
users_collections::hide_passwords.eq(hide_passwords),
))
.execute(conn)
.map_res("Error adding user to collection")
}
Err(e) => Err(e.into()),
}.map_res("Error adding user to collection")
} }
postgresql { postgresql {
diesel::insert_into(users_collections::table) diesel::insert_into(users_collections::table)
@ -344,8 +372,11 @@ impl CollectionCipher {
pub fn save(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult { pub fn save(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult {
Self::update_users_revision(&collection_uuid, conn); Self::update_users_revision(&collection_uuid, conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
// Not checking for ForeignKey Constraints here.
// Table ciphers_collections does not have ForeignKey Constraints which would cause conflicts.
// This table has no constraints pointing to itself, but only to others.
diesel::replace_into(ciphers_collections::table) diesel::replace_into(ciphers_collections::table)
.values(( .values((
ciphers_collections::cipher_uuid.eq(cipher_uuid), ciphers_collections::cipher_uuid.eq(cipher_uuid),
@ -370,7 +401,7 @@ impl CollectionCipher {
pub fn delete(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult { pub fn delete(cipher_uuid: &str, collection_uuid: &str, conn: &DbConn) -> EmptyResult {
Self::update_users_revision(&collection_uuid, conn); Self::update_users_revision(&collection_uuid, conn);
db_run! { conn: { db_run! { conn: {
diesel::delete( diesel::delete(
ciphers_collections::table ciphers_collections::table

30
src/db/models/folder.rs
Datei anzeigen

@ -74,12 +74,23 @@ impl Folder {
User::update_uuid_revision(&self.user_uuid, conn); User::update_uuid_revision(&self.user_uuid, conn);
self.updated_at = Utc::now().naive_utc(); self.updated_at = Utc::now().naive_utc();
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(folders::table) match diesel::replace_into(folders::table)
.values(FolderDb::to_db(self)) .values(FolderDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving folder") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(folders::table)
.filter(folders::uuid.eq(&self.uuid))
.set(FolderDb::to_db(self))
.execute(conn)
.map_res("Error saving folder")
}
Err(e) => Err(e.into()),
}.map_res("Error saving folder")
} }
postgresql { postgresql {
let value = FolderDb::to_db(self); let value = FolderDb::to_db(self);
@ -98,7 +109,7 @@ impl Folder {
User::update_uuid_revision(&self.user_uuid, conn); User::update_uuid_revision(&self.user_uuid, conn);
FolderCipher::delete_all_by_folder(&self.uuid, &conn)?; FolderCipher::delete_all_by_folder(&self.uuid, &conn)?;
db_run! { conn: { db_run! { conn: {
diesel::delete(folders::table.filter(folders::uuid.eq(&self.uuid))) diesel::delete(folders::table.filter(folders::uuid.eq(&self.uuid)))
.execute(conn) .execute(conn)
@ -136,8 +147,11 @@ impl Folder {
impl FolderCipher { impl FolderCipher {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
// Not checking for ForeignKey Constraints here.
// Table folders_ciphers does not have ForeignKey Constraints which would cause conflicts.
// This table has no constraints pointing to itself, but only to others.
diesel::replace_into(folders_ciphers::table) diesel::replace_into(folders_ciphers::table)
.values(FolderCipherDb::to_db(self)) .values(FolderCipherDb::to_db(self))
.execute(conn) .execute(conn)
@ -149,9 +163,9 @@ impl FolderCipher {
.on_conflict((folders_ciphers::cipher_uuid, folders_ciphers::folder_uuid)) .on_conflict((folders_ciphers::cipher_uuid, folders_ciphers::folder_uuid))
.do_nothing() .do_nothing()
.execute(conn) .execute(conn)
.map_res("Error adding cipher to folder") .map_res("Error adding cipher to folder")
} }
} }
} }
pub fn delete(self, conn: &DbConn) -> EmptyResult { pub fn delete(self, conn: &DbConn) -> EmptyResult {

17
src/db/models/org_policy.rs
Datei anzeigen

@ -56,12 +56,23 @@ impl OrgPolicy {
/// Database methods /// Database methods
impl OrgPolicy { impl OrgPolicy {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(org_policies::table) match diesel::replace_into(org_policies::table)
.values(OrgPolicyDb::to_db(self)) .values(OrgPolicyDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving org_policy") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(org_policies::table)
.filter(org_policies::uuid.eq(&self.uuid))
.set(OrgPolicyDb::to_db(self))
.execute(conn)
.map_res("Error saving org_policy")
}
Err(e) => Err(e.into()),
}.map_res("Error saving org_policy")
} }
postgresql { postgresql {
let value = OrgPolicyDb::to_db(self); let value = OrgPolicyDb::to_db(self);

41
src/db/models/organization.rs
Datei anzeigen

@ -204,12 +204,24 @@ impl Organization {
User::update_uuid_revision(&user_org.user_uuid, conn); User::update_uuid_revision(&user_org.user_uuid, conn);
}); });
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(organizations::table) match diesel::replace_into(organizations::table)
.values(OrganizationDb::to_db(self)) .values(OrganizationDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving organization") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(organizations::table)
.filter(organizations::uuid.eq(&self.uuid))
.set(OrganizationDb::to_db(self))
.execute(conn)
.map_res("Error saving organization")
}
Err(e) => Err(e.into()),
}.map_res("Error saving organization")
} }
postgresql { postgresql {
let value = OrganizationDb::to_db(self); let value = OrganizationDb::to_db(self);
@ -219,7 +231,7 @@ impl Organization {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error saving organization") .map_res("Error saving organization")
} }
} }
} }
@ -259,7 +271,7 @@ impl Organization {
impl UserOrganization { impl UserOrganization {
pub fn to_json(&self, conn: &DbConn) -> Value { pub fn to_json(&self, conn: &DbConn) -> Value {
let org = Organization::find_by_uuid(&self.org_uuid, conn).unwrap(); let org = Organization::find_by_uuid(&self.org_uuid, conn).unwrap();
json!({ json!({
"Id": self.org_uuid, "Id": self.org_uuid,
"Name": org.name, "Name": org.name,
@ -343,12 +355,23 @@ impl UserOrganization {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
User::update_uuid_revision(&self.user_uuid, conn); User::update_uuid_revision(&self.user_uuid, conn);
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(users_organizations::table) match diesel::replace_into(users_organizations::table)
.values(UserOrganizationDb::to_db(self)) .values(UserOrganizationDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error adding user to organization") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(users_organizations::table)
.filter(users_organizations::uuid.eq(&self.uuid))
.set(UserOrganizationDb::to_db(self))
.execute(conn)
.map_res("Error adding user to organization")
}
Err(e) => Err(e.into()),
}.map_res("Error adding user to organization")
} }
postgresql { postgresql {
let value = UserOrganizationDb::to_db(self); let value = UserOrganizationDb::to_db(self);
@ -358,7 +381,7 @@ impl UserOrganization {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error adding user to organization") .map_res("Error adding user to organization")
} }
} }
} }

19
src/db/models/two_factor.rs
Datei anzeigen

@ -71,12 +71,23 @@ impl TwoFactor {
/// Database methods /// Database methods
impl TwoFactor { impl TwoFactor {
pub fn save(&self, conn: &DbConn) -> EmptyResult { pub fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn: db_run! { conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(twofactor::table) match diesel::replace_into(twofactor::table)
.values(TwoFactorDb::to_db(self)) .values(TwoFactorDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving twofactor") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(twofactor::table)
.filter(twofactor::uuid.eq(&self.uuid))
.set(TwoFactorDb::to_db(self))
.execute(conn)
.map_res("Error saving twofactor")
}
Err(e) => Err(e.into()),
}.map_res("Error saving twofactor")
} }
postgresql { postgresql {
let value = TwoFactorDb::to_db(self); let value = TwoFactorDb::to_db(self);
@ -93,7 +104,7 @@ impl TwoFactor {
.do_update() .do_update()
.set(&value) .set(&value)
.execute(conn) .execute(conn)
.map_res("Error saving twofactor") .map_res("Error saving twofactor")
} }
} }
} }

23
src/db/models/user.rs
Datei anzeigen

@ -175,10 +175,21 @@ impl User {
db_run! {conn: db_run! {conn:
sqlite, mysql { sqlite, mysql {
diesel::replace_into(users::table) // Insert or update match diesel::replace_into(users::table)
.values(&UserDb::to_db(self)) .values(UserDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving user") {
Ok(_) => Ok(()),
// Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
diesel::update(users::table)
.filter(users::uuid.eq(&self.uuid))
.set(UserDb::to_db(self))
.execute(conn)
.map_res("Error saving user")
}
Err(e) => Err(e.into()),
}.map_res("Error saving user")
} }
postgresql { postgresql {
let value = UserDb::to_db(self); let value = UserDb::to_db(self);
@ -290,10 +301,12 @@ impl Invitation {
db_run! {conn: db_run! {conn:
sqlite, mysql { sqlite, mysql {
// Not checking for ForeignKey Constraints here
// Table invitations does not have any ForeignKey Constraints.
diesel::replace_into(invitations::table) diesel::replace_into(invitations::table)
.values(InvitationDb::to_db(self)) .values(InvitationDb::to_db(self))
.execute(conn) .execute(conn)
.map_res("Error saving invitation") .map_res("Error saving invitation")
} }
postgresql { postgresql {
diesel::insert_into(invitations::table) diesel::insert_into(invitations::table)
@ -301,7 +314,7 @@ impl Invitation {
.on_conflict(invitations::email) .on_conflict(invitations::email)
.do_nothing() .do_nothing()
.execute(conn) .execute(conn)
.map_res("Error saving invitation") .map_res("Error saving invitation")
} }
} }
} }