dan/Portfolio
1
0
Fork 0
mirror of https://github.com/danbulant/Portfolio synced 2026-06-24 17:11:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat: optimize candidate details

Browse source
This commit is contained in:
Sebastian Pravda 2022-12-14 16:58:03 +01:00
parent 787b234048
commit 7bce4bf0bc
No known key found for this signature in database
GPG key ID: F3BC84F08EFA3F57
4 changed files with 70 additions and 59 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

119
core/src/models/candidate_details.rs
View file

@ -1,6 +1,7 @@
use chrono::NaiveDate; use chrono::NaiveDate;
use entity::{candidate, parent}; use entity::{candidate, parent};
use futures::future;
use crate::{crypto, models::candidate::{CandidateWithParent, ApplicationDetails}, error::ServiceError}; use crate::{crypto, models::candidate::{CandidateWithParent, ApplicationDetails}, error::ServiceError};
@ -83,7 +84,6 @@ impl From<String> for EncryptedString {
} }
impl TryFrom<Option<NaiveDate>> for EncryptedString { impl TryFrom<Option<NaiveDate>> for EncryptedString {
// TODO: take a look at this
type Error = ServiceError; type Error = ServiceError;
fn try_from(d: Option<NaiveDate>) -> Result<Self, Self::Error> { fn try_from(d: Option<NaiveDate>) -> Result<Self, Self::Error> {
@ -97,20 +97,20 @@ impl TryFrom<Option<NaiveDate>> for EncryptedString {
impl EncryptedCandidateDetails { impl EncryptedCandidateDetails {
pub async fn new( pub async fn new(
form: &CandidateDetails, form: &CandidateDetails,
recipients: Vec<String>, recipients: &Vec<String>,
) -> Result<EncryptedCandidateDetails, ServiceError> { ) -> Result<EncryptedCandidateDetails, ServiceError> {
let birthdate_str = form.birthdate.format(NAIVE_DATE_FMT).to_string(); let birthdate_str = form.birthdate.format(NAIVE_DATE_FMT).to_string();
let d = tokio::try_join!( let d = tokio::try_join!(
EncryptedString::new(&form.name, &recipients), EncryptedString::new(&form.name, recipients),
EncryptedString::new(&form.surname, &recipients), EncryptedString::new(&form.surname, recipients),
EncryptedString::new(&form.birthplace, &recipients), EncryptedString::new(&form.birthplace, recipients),
EncryptedString::new(&birthdate_str, &recipients), EncryptedString::new(&birthdate_str, recipients),
EncryptedString::new(&form.address, &recipients), EncryptedString::new(&form.address, recipients),
EncryptedString::new(&form.telephone, &recipients), EncryptedString::new(&form.telephone, recipients),
EncryptedString::new(&form.citizenship, &recipients), EncryptedString::new(&form.citizenship, recipients),
EncryptedString::new(&form.email, &recipients), EncryptedString::new(&form.email, recipients),
EncryptedString::new(&form.sex, &recipients), EncryptedString::new(&form.sex, recipients),
EncryptedString::new(&form.personal_id_number, &recipients), EncryptedString::new(&form.personal_id_number, recipients),
)?; )?;
Ok( Ok(
@ -187,13 +187,13 @@ impl TryFrom<candidate::Model> for EncryptedCandidateDetails {
impl EncryptedParentDetails { impl EncryptedParentDetails {
pub async fn new( pub async fn new(
form: &ParentDetails, form: &ParentDetails,
recipients: Vec<String>, recipients: &Vec<String>,
) -> Result<EncryptedParentDetails, ServiceError> { ) -> Result<EncryptedParentDetails, ServiceError> {
let d = tokio::try_join!( let d = tokio::try_join!(
EncryptedString::new(&form.name, &recipients), EncryptedString::new(&form.name, recipients),
EncryptedString::new(&form.surname, &recipients), EncryptedString::new(&form.surname, recipients),
EncryptedString::new(&form.telephone, &recipients), EncryptedString::new(&form.telephone, recipients),
EncryptedString::new(&form.email, &recipients), EncryptedString::new(&form.email, recipients),
)?; )?;
Ok( Ok(
@ -244,11 +244,11 @@ impl EncryptedApplicationDetails {
form: &ApplicationDetails, form: &ApplicationDetails,
recipients: Vec<String>, recipients: Vec<String>,
) -> Result<EncryptedApplicationDetails, ServiceError> { ) -> Result<EncryptedApplicationDetails, ServiceError> {
let candidate = EncryptedCandidateDetails::new(&form.candidate, recipients.clone()).await?; let candidate = EncryptedCandidateDetails::new(&form.candidate, &recipients).await?;
let mut enc_parents= vec![]; let mut enc_parents= vec![];
for parent in form.parents.iter() { for parent in form.parents.iter() {
enc_parents.push( enc_parents.push(
EncryptedParentDetails::new(parent, recipients.clone()).await? EncryptedParentDetails::new(parent, &recipients).await?
); );
} }
Ok( Ok(
@ -260,15 +260,17 @@ impl EncryptedApplicationDetails {
} }
pub async fn decrypt(self, priv_key: String) -> Result<ApplicationDetails, ServiceError> { pub async fn decrypt(self, priv_key: String) -> Result<ApplicationDetails, ServiceError> {
let candidate = self.candidate.decrypt(priv_key.clone()).await?; let decrypted_candidate = self.candidate.decrypt(priv_key.clone()).await?;
let mut parents = vec![];
for parent in self.parents.iter() { let decrypted_parents = future::try_join_all(
let dec = parent.decrypt(priv_key.clone()).await?; self.parents
parents.push(dec); .iter()
} .map(|d| d.decrypt(priv_key.clone()))
).await?;
Ok(ApplicationDetails { Ok(ApplicationDetails {
candidate, candidate: decrypted_candidate,
parents: parents, parents: decrypted_parents,
}) })
} }
} }
@ -339,9 +341,12 @@ pub async fn decrypt_if_exists(
pub mod tests { pub mod tests {
use std::sync::Mutex; use std::sync::Mutex;
use chrono::{Local};
use entity::admin;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use sea_orm::{DbConn, Set, ActiveModelTrait};
use crate::{crypto, models::candidate::{CandidateDetails, ParentDetails}}; use crate::{crypto, models::candidate::{CandidateDetails, ParentDetails}, utils::db::get_memory_sqlite_connection, Query, services::candidate_service::tests::put_user_data};
use super::{ApplicationDetails, EncryptedApplicationDetails, EncryptedString}; use super::{ApplicationDetails, EncryptedApplicationDetails, EncryptedString};
@ -384,10 +389,30 @@ pub mod tests {
assert_eq!(details.candidate.sex, "sex"); assert_eq!(details.candidate.sex, "sex");
assert_eq!(details.candidate.study, "study"); assert_eq!(details.candidate.study, "study");
assert_eq!(details.candidate.personal_id_number, "personal_id_number"); assert_eq!(details.candidate.personal_id_number, "personal_id_number");
assert_eq!(details.parents[0].name, "parent_name"); for parent in &details.parents {
assert_eq!(details.parents[0].surname, "parent_surname"); assert_eq!(parent.name, "parent_name");
assert_eq!(details.parents[0].telephone, "parent_telephone"); assert_eq!(parent.surname, "parent_surname");
assert_eq!(details.parents[0].email, "parent_email"); assert_eq!(parent.telephone, "parent_telephone");
assert_eq!(parent.email, "parent_email");
}
}
async fn insert_test_admin(db: &DbConn) -> admin::Model {
admin::ActiveModel {
id: Set(1),
name: Set("Admin".to_owned()),
public_key: Set("age1u889gp407hsz309wn09kxx9anl6uns30m27lfwnctfyq9tq4qpus8tzmq5".to_owned()),
// AGE-SECRET-KEY-14QG24502DMUUQDT2SPMX2YXPSES0X8UD6NT0PCTDAT6RH8V5Q3GQGSRXPS
private_key: Set("5KCEGk0ueWVGnu5Xo3rmpLoilcVZ2ZWmwIcdZEJ8rrBNW7jwzZU/XTcTXtk/xyy/zjF8s+YnuVpOklQvX3EC/Sn+ZwyPY3jokM2RNwnZZlnqdehOEV1SMm/Y".to_owned()),
// test
password: Set("$argon2i$v=19$m=6000,t=3,p=10$WE9xCQmmWdBK82R4SEjoqA$TZSc6PuLd4aWK2x2WAb+Lm9sLySqjK3KLbNyqyQmzPQ".to_owned()),
created_at: Set(Local::now().naive_local()),
updated_at: Set(Local::now().naive_local()),
..Default::default()
}
.insert(db)
.await
.unwrap()
} }
#[tokio::test] #[tokio::test]
@ -436,35 +461,25 @@ pub mod tests {
assert_all_application_details(&application_details); assert_all_application_details(&application_details);
} }
// TODO #[tokio::test]
/* #[tokio::test]
async fn test_encrypted_application_details_from_candidate_parent() { async fn test_encrypted_application_details_from_candidate_parent() {
const PUBLIC_KEY: &str = "age1u889gp407hsz309wn09kxx9anl6uns30m27lfwnctfyq9tq4qpus8tzmq5"; let db = get_memory_sqlite_connection().await;
const PRIVATE_KEY: &str = let _admin = insert_test_admin(&db).await;
"AGE-SECRET-KEY-14QG24502DMUUQDT2SPMX2YXPSES0X8UD6NT0PCTDAT6RH8V5Q3GQGSRXPS";
const birthdate: NaiveDate = chrono::offset::Local::now().date_naive(); let (candidate, parents) = put_user_data(&db).await;
let encrypted_details = EncryptedApplicationDetails::try_from(
, let encrypted_details = EncryptedApplicationDetails::try_from((candidate, parents)).unwrap();
vec![PUBLIC_KEY],
)
.await
.unwrap();
let application_details = encrypted_details let application_details = encrypted_details
.decrypt(PRIVATE_KEY.to_string()) .decrypt(PRIVATE_KEY.to_string()) // decrypt with admin's private key
.await .await
.unwrap(); .unwrap();
assert_all_application_details(&application_details); assert_all_application_details(&application_details);
} */ }
#[tokio::test] #[tokio::test]
async fn test_encrypted_string_new() { async fn test_encrypted_string_new() {
const PUBLIC_KEY: &str = "age1u889gp407hsz309wn09kxx9anl6uns30m27lfwnctfyq9tq4qpus8tzmq5";
const PRIVATE_KEY: &str =
"AGE-SECRET-KEY-14QG24502DMUUQDT2SPMX2YXPSES0X8UD6NT0PCTDAT6RH8V5Q3GQGSRXPS";
let encrypted = EncryptedString::new("test", &vec![PUBLIC_KEY.to_string()]) let encrypted = EncryptedString::new("test", &vec![PUBLIC_KEY.to_string()])
.await .await
.unwrap(); .unwrap();
@ -479,10 +494,6 @@ pub mod tests {
#[tokio::test] #[tokio::test]
async fn test_encrypted_string_decrypt() { async fn test_encrypted_string_decrypt() {
const PUBLIC_KEY: &str = "age1u889gp407hsz309wn09kxx9anl6uns30m27lfwnctfyq9tq4qpus8tzmq5";
const PRIVATE_KEY: &str =
"AGE-SECRET-KEY-14QG24502DMUUQDT2SPMX2YXPSES0X8UD6NT0PCTDAT6RH8V5Q3GQGSRXPS";
let encrypted = EncryptedString::new("test", &vec![PUBLIC_KEY.to_string()]) let encrypted = EncryptedString::new("test", &vec![PUBLIC_KEY.to_string()])
.await .await
.unwrap(); .unwrap();

5
core/src/services/application_service.rs
View file

@ -28,10 +28,11 @@ impl ApplicationService {
form: &ApplicationDetails, form: &ApplicationDetails,
) -> Result<(candidate::Model, Vec<parent::Model>), ServiceError> { // TODO: is this service needed? ) -> Result<(candidate::Model, Vec<parent::Model>), ServiceError> { // TODO: is this service needed?
let recipients = get_recipients(db, &candidate.public_key).await?;
Ok( Ok(
( (
CandidateService::add_candidate_details(db, candidate.clone(), &form.candidate).await?, CandidateService::add_candidate_details(db, candidate.clone(), &form.candidate, &recipients).await?,
ParentService::add_parents_details(db, candidate, &form.parents).await? ParentService::add_parents_details(db, candidate, &form.parents, &recipients).await?
) )
) )
} }

3
core/src/services/candidate_service.rs
View file

@ -118,7 +118,6 @@ impl CandidateService {
Mutation::update_candidate_password_and_keys(db, candidate.clone(), new_password_hash, pubkey, encrypted_priv_key).await?; Mutation::update_candidate_password_and_keys(db, candidate.clone(), new_password_hash, pubkey, encrypted_priv_key).await?;
// user might no have filled his details yet, but personal id number is filled from beginning // user might no have filled his details yet, but personal id number is filled from beginning
// TODO: make personal id number required
let personal_id_number = EncryptedString::from(candidate.personal_identification_number.clone()) let personal_id_number = EncryptedString::from(candidate.personal_identification_number.clone())
.decrypt(&admin_private_key) .decrypt(&admin_private_key)
.await?; .await?;
@ -150,8 +149,8 @@ impl CandidateService {
db: &DbConn, db: &DbConn,
candidate: candidate::Model, candidate: candidate::Model,
details: &CandidateDetails, details: &CandidateDetails,
recipients: &Vec<String>,
) -> Result<entity::candidate::Model, ServiceError> { ) -> Result<entity::candidate::Model, ServiceError> {
let recipients = get_recipients(db, &candidate.public_key).await?;
let enc_details = EncryptedCandidateDetails::new(&details, recipients).await?; let enc_details = EncryptedCandidateDetails::new(&details, recipients).await?;
let model = Mutation::add_candidate_details(db, candidate, enc_details).await?; let model = Mutation::add_candidate_details(db, candidate, enc_details).await?;
Ok(model) Ok(model)

2
core/src/services/parent_service.rs
View file

@ -30,6 +30,7 @@ impl ParentService {
db: &DbConn, db: &DbConn,
ref_candidate: candidate::Model, ref_candidate: candidate::Model,
parents_details: &Vec<ParentDetails>, parents_details: &Vec<ParentDetails>,
recipients: &Vec<String>,
) -> Result<Vec<parent::Model>, ServiceError> { ) -> Result<Vec<parent::Model>, ServiceError> {
let found_parents = Query::find_candidate_parents(db, ref_candidate.clone()).await?; let found_parents = Query::find_candidate_parents(db, ref_candidate.clone()).await?;
if found_parents.len() > 2 { if found_parents.len() > 2 {
@ -42,7 +43,6 @@ impl ParentService {
Some(parent) => parent.clone(), Some(parent) => parent.clone(),
None => ParentService::create(db, ref_candidate.application).await?, None => ParentService::create(db, ref_candidate.application).await?,
}; };
let recipients = get_recipients(db, &ref_candidate.public_key).await?;
let enc_details = EncryptedParentDetails::new(&parents_details[i], recipients).await?; let enc_details = EncryptedParentDetails::new(&parents_details[i], recipients).await?;
let parent = Mutation::add_parent_details(db, found_parent.clone(), enc_details.clone()).await?; let parent = Mutation::add_parent_details(db, found_parent.clone(), enc_details.clone()).await?;
result.push(parent); result.push(parent);