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

fix: list candidates

Browse source
This commit is contained in:
Sebastian Pravda 2023-01-14 15:16:44 +01:00
parent cf25920a5c
commit 61facc503c
No known key found for this signature in database
GPG key ID: F3BC84F08EFA3F57
21 changed files with 178 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
api/src/routes/admin.rs
View file

@ -2,7 +2,7 @@ use std::net::{SocketAddr, IpAddr, Ipv4Addr};
use portfolio_core::{
crypto::random_12_char_string,
services::{admin_service::AdminService, candidate_service::CandidateService, application_service::ApplicationService, portfolio_service::PortfolioService}, models::{candidate::{BaseCandidateResponse, CreateCandidateResponse, ApplicationDetails}, auth::AuthenticableTrait}, sea_orm::prelude::Uuid, Query, error::ServiceError, utils::csv,
services::{admin_service::AdminService, candidate_service::CandidateService, application_service::ApplicationService, portfolio_service::PortfolioService}, models::{candidate::{BaseCandidateResponse, CreateCandidateResponse, ApplicationDetails}, auth::AuthenticableTrait, application::ApplicationResponse}, sea_orm::prelude::Uuid, Query, error::ServiceError, utils::csv,
};
use requests::{AdminLoginRequest, RegisterRequest};
use rocket::http::{Cookie, Status, CookieJar};
@ -114,7 +114,7 @@ pub async fn list_candidates(
session: AdminAuth,
field: Option<String>,
page: Option<u64>,
) -> Result<Json<Vec<BaseCandidateResponse>>, Custom<String>> {
) -> Result<Json<Vec<ApplicationResponse>>, Custom<String>> {
let db = conn.into_inner();
let private_key = session.get_private_key();
if let Some(field) = field.clone() {
@ -124,9 +124,11 @@ pub async fn list_candidates(
}
let candidates = CandidateService::list_candidates(&private_key, db, field, page)
/* let candidates = CandidateService::list_candidates(&private_key, db, field, page)
.await
.map_err(to_custom_error)?;
.map_err(to_custom_error)?; */
let candidates = ApplicationService::list_applications(&private_key, db)
.await.map_err(to_custom_error)?;
Ok(
Json(candidates)

35
api/src/routes/candidate.rs
View file

@ -6,7 +6,6 @@ use portfolio_core::models::auth::AuthenticableTrait;
use portfolio_core::models::candidate::{ApplicationDetails, NewCandidateResponse};
use portfolio_core::sea_orm::prelude::Uuid;
use portfolio_core::services::application_service::ApplicationService;
use portfolio_core::services::candidate_service::CandidateService;
use portfolio_core::services::portfolio_service::{PortfolioService, SubmissionProgress};
use requests::LoginRequest;
use rocket::http::{Cookie, CookieJar, Status};
@ -127,9 +126,9 @@ pub async fn upload_cover_letter(
session: ApplicationAuth,
letter: Letter,
) -> Result<(), Custom<String>> {
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
PortfolioService::add_cover_letter_to_cache(candidate.id, letter.into())
PortfolioService::add_cover_letter_to_cache(application.candidate_id, letter.into())
.await
.map_err(to_custom_error)?;
@ -138,9 +137,9 @@ pub async fn upload_cover_letter(
#[delete("/cover_letter")]
pub async fn delete_cover_letter(session: ApplicationAuth) -> Result<(), Custom<String>> {
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
PortfolioService::delete_cover_letter_from_cache(candidate.id)
PortfolioService::delete_cover_letter_from_cache(application.candidate_id)
.await
.map_err(to_custom_error)?;
@ -152,9 +151,9 @@ pub async fn upload_portfolio_letter(
session: ApplicationAuth,
letter: Letter,
) -> Result<(), Custom<String>> {
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
PortfolioService::add_portfolio_letter_to_cache(candidate.id, letter.into())
PortfolioService::add_portfolio_letter_to_cache(application.candidate_id, letter.into())
.await
.map_err(to_custom_error)?;
@ -165,7 +164,7 @@ pub async fn upload_portfolio_letter(
pub async fn delete_portfolio_letter(session: ApplicationAuth) -> Result<(), Custom<String>> {
let candidate: entity::application::Model = session.into();
PortfolioService::delete_portfolio_letter_from_cache(candidate.id)
PortfolioService::delete_portfolio_letter_from_cache(candidate.candidate_id)
.await
.map_err(to_custom_error)?;
@ -177,9 +176,9 @@ pub async fn upload_portfolio_zip(
session: ApplicationAuth,
portfolio: Portfolio,
) -> Result<(), Custom<String>> {
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
PortfolioService::add_portfolio_zip_to_cache(candidate.id, portfolio.into())
PortfolioService::add_portfolio_zip_to_cache(application.candidate_id, portfolio.into())
.await
.map_err(to_custom_error)?;
@ -188,9 +187,9 @@ pub async fn upload_portfolio_zip(
#[delete("/portfolio_zip")]
pub async fn delete_portfolio_zip(session: ApplicationAuth) -> Result<(), Custom<String>> {
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
PortfolioService::delete_portfolio_zip_from_cache(candidate.id)
PortfolioService::delete_portfolio_zip_from_cache(application.candidate_id)
.await
.map_err(to_custom_error)?;
@ -201,9 +200,9 @@ pub async fn delete_portfolio_zip(session: ApplicationAuth) -> Result<(), Custom
pub async fn submission_progress(
session: ApplicationAuth,
) -> Result<Json<SubmissionProgress>, Custom<String>> {
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
let progress = PortfolioService::get_submission_progress(candidate.id)
let progress = PortfolioService::get_submission_progress(application.candidate_id)
.await
.map(|x| Json(x))
.map_err(to_custom_error);
@ -242,9 +241,9 @@ pub async fn submit_portfolio(
pub async fn delete_portfolio(
session: ApplicationAuth,
) -> Result<(), Custom<String>> {
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
PortfolioService::delete_portfolio(candidate.id)
PortfolioService::delete_portfolio(application.candidate_id)
.await
.map_err(to_custom_error)?;
@ -254,9 +253,9 @@ pub async fn delete_portfolio(
#[get("/download")]
pub async fn download_portfolio(session: ApplicationAuth) -> Result<Vec<u8>, Custom<String>> {
let private_key = session.get_private_key();
let candidate: entity::application::Model = session.into();
let application: entity::application::Model = session.into();
let file = PortfolioService::get_portfolio(candidate.id, private_key)
let file = PortfolioService::get_portfolio(application.candidate_id, private_key)
.await
.map_err(to_custom_error);

10
core/src/database/mutation/candidate.rs
View file

@ -18,7 +18,7 @@ impl Mutation {
.insert(db)
.await?;
info!("CANDIDATE {} CREATED", candidate.application);
info!("CANDIDATE {} CREATED", candidate.id);
Ok(candidate)
}
@ -35,7 +35,7 @@ impl Mutation {
db: &DbConn,
candidate: candidate::Model,
) -> Result<DeleteResult, DbErr> {
let application = candidate.application;
let application = candidate.id;
let delete = candidate.delete(db).await?;
warn!("CANDIDATE {} DELETED", application);
@ -47,7 +47,7 @@ impl Mutation {
user: candidate::Model,
enc_candidate: EncryptedCandidateDetails,
) -> Result<candidate::Model, sea_orm::DbErr> {
let application = user.application;
let application = user.id;
let mut candidate: candidate::ActiveModel = user.into();
candidate.name = Set(enc_candidate.name.map(|e| e.into()));
@ -92,7 +92,7 @@ mod tests {
.await
.unwrap();
let candidate = Query::find_candidate_by_id(&db, candidate.application)
let candidate = Query::find_candidate_by_id(&db, candidate.id)
.await
.unwrap();
assert!(candidate.is_some());
@ -116,7 +116,7 @@ mod tests {
let candidate = Mutation::update_candidate_details(&db, candidate, encrypted_details.candidate).await.unwrap();
let candidate = Query::find_candidate_by_id(&db, candidate.application)
let candidate = Query::find_candidate_by_id(&db, candidate.id)
.await
.unwrap().unwrap();

4
core/src/database/mutation/parent.rs
View file

@ -56,7 +56,7 @@ mod tests {
.await
.unwrap();
let new_parent = Mutation::create_parent(&db, candidate.application).await.unwrap();
let new_parent = Mutation::create_parent(&db, candidate.id).await.unwrap();
let parent = Query::find_parent_by_id(&db, new_parent.id).await.unwrap();
assert!(parent.is_some());
@ -73,7 +73,7 @@ mod tests {
.await
.unwrap();
let parent = Mutation::create_parent(&db, candidate.application).await.unwrap();
let parent = Mutation::create_parent(&db, candidate.id).await.unwrap();
let encrypted_details: EncryptedApplicationDetails = EncryptedApplicationDetails::new(
&APPLICATION_DETAILS.lock().unwrap().clone(),

32
core/src/database/query/application.rs
View file

@ -1,5 +1,17 @@
use entity::{application, candidate};
use sea_orm::{EntityTrait, DbErr, DbConn, ModelTrait};
use sea_orm::{EntityTrait, DbErr, DbConn, ModelTrait, FromQueryResult, QuerySelect, JoinType, RelationTrait};
#[derive(FromQueryResult, Clone)]
pub struct ApplicationCandidateJoin {
pub application_id: i32,
// pub personal_id_number: String,
pub candidate_id: i32,
pub name: Option<String>,
pub surname: Option<String>,
pub email: Option<String>,
pub telephone: Option<String>,
pub study: Option<String>,
}
use crate::Query;
@ -22,4 +34,22 @@ impl Query {
.one(db)
.await
}
pub async fn list_applications(
db: &DbConn,
) -> Result<Vec<ApplicationCandidateJoin>, DbErr> {
application::Entity::find()
// .column_as(application::Column::Id, "application_id")
.join(JoinType::InnerJoin, application::Relation::Candidate.def())
.column_as(application::Column::Id, "application_id")
.column_as(candidate::Column::Id, "candidate_id")
.column_as(candidate::Column::Name, "name")
.column_as(candidate::Column::Surname, "surname")
.column_as(candidate::Column::Email, "email")
.column_as(candidate::Column::Telephone, "telephone")
.column_as(candidate::Column::Study, "study")
.into_model::<ApplicationCandidateJoin>()
.all(db)
.await
}
}

12
core/src/database/query/candidate.rs
View file

@ -49,7 +49,7 @@ impl Query {
} else {
select
}
.order_by(candidate::Column::Application, Order::Asc)
.order_by(candidate::Column::Id, Order::Asc)
.into_model::<CandidateResult>();
if let Some(page) = page {
@ -66,7 +66,7 @@ impl Query {
db: &DbConn
) -> Result<Vec<candidate::Model>, DbErr> {
Candidate::find()
.order_by(candidate::Column::Application, Order::Asc)
.order_by(candidate::Column::Id, Order::Asc)
.all(db)
.await
}
@ -75,8 +75,8 @@ impl Query {
db: &DbConn,
) -> Result<Vec<ApplicationId>, DbErr> {
Candidate::find()
.order_by(candidate::Column::Application, Order::Asc)
.column(candidate::Column::Application)
.order_by(candidate::Column::Id, Order::Asc)
.column(candidate::Column::Id)
.into_model::<ApplicationId>()
.all(db)
.await
@ -97,7 +97,7 @@ mod tests {
async fn test_find_candidate_by_id() {
let db = get_memory_sqlite_connection().await;
let candidate = candidate::ActiveModel {
application: Set(103158),
id: Set(103158),
personal_identification_number: Set("test".to_string()),
created_at: Set(chrono::offset::Local::now().naive_local()),
updated_at: Set(chrono::offset::Local::now().naive_local()),
@ -107,7 +107,7 @@ mod tests {
.await
.unwrap();
let candidate = Query::find_candidate_by_id(&db, candidate.application)
let candidate = Query::find_candidate_by_id(&db, candidate.id)
.await
.unwrap();
assert!(candidate.is_some());

2
core/src/database/query/parent.rs
View file

@ -45,7 +45,7 @@ mod tests {
const APPLICATION_ID: i32 = 103158;
candidate::ActiveModel {
application: Set(APPLICATION_ID),
id: Set(APPLICATION_ID),
personal_identification_number: Set("test".to_string()),
created_at: Set(chrono::offset::Local::now().naive_local()),
updated_at: Set(chrono::offset::Local::now().naive_local()),

42
core/src/models/application.rs Normal file
View file

@ -0,0 +1,42 @@
use serde::{Serialize, Deserialize};
use crate::{database::query::application::ApplicationCandidateJoin, services::portfolio_service::SubmissionProgress, error::ServiceError};
use super::candidate_details::EncryptedString;
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ApplicationResponse {
pub application_id: i32,
// pub personal_id_number: String,
pub candidate_id: i32,
pub name: String,
pub surname: String,
pub email: String,
pub telephone: String,
pub study: String,
}
impl ApplicationResponse {
pub async fn from_encrypted(
private_key: &String,
c: ApplicationCandidateJoin
) -> Result<Self, ServiceError> {
let name = EncryptedString::decrypt_option(&EncryptedString::try_from(&c.name).ok(), private_key).await?;
let surname = EncryptedString::decrypt_option(&EncryptedString::try_from(&c.surname).ok(), private_key).await?;
let email = EncryptedString::decrypt_option(&EncryptedString::try_from(&c.email).ok(), private_key).await?;
let telephone = EncryptedString::decrypt_option(&EncryptedString::try_from(&c.telephone).ok(), private_key).await?;
Ok(
Self {
application_id: c.application_id,
name: name.unwrap_or_default(),
surname: surname.unwrap_or_default(),
email: email.unwrap_or_default(),
telephone: telephone.unwrap_or_default(),
study: c.study.unwrap_or_default(),
candidate_id: c.candidate_id,
}
)
}
}

2
core/src/models/candidate.rs
View file

@ -108,7 +108,7 @@ impl NewCandidateResponse {
let id_number = EncryptedString::from(c.personal_identification_number).decrypt(private_key).await?;
Ok(
Self {
application_id: c.application,
application_id: c.id,
personal_id_number: id_number,
}
)

3
core/src/models/mod.rs
View file

@ -1,3 +1,4 @@
pub mod candidate_details;
pub mod candidate;
pub mod auth;
pub mod auth;
pub mod application;

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

@ -3,9 +3,9 @@ use chrono::Duration;
use entity::{candidate, parent, application, session};
use sea_orm::{DbConn, prelude::Uuid, IntoActiveModel};
use crate::{error::ServiceError, Query, utils::db::get_recipients, models::candidate_details::{EncryptedApplicationDetails}, models::{candidate::ApplicationDetails, candidate_details::EncryptedString, auth::AuthenticableTrait}, Mutation, crypto::{hash_password, self}};
use crate::{error::ServiceError, Query, utils::db::get_recipients, models::candidate_details::{EncryptedApplicationDetails}, models::{candidate::ApplicationDetails, candidate_details::EncryptedString, auth::AuthenticableTrait, application::ApplicationResponse}, Mutation, crypto::{hash_password, self}};
use super::{parent_service::ParentService, candidate_service::CandidateService, session_service::SessionService};
use super::{parent_service::ParentService, candidate_service::CandidateService, session_service::SessionService, portfolio_service::PortfolioService};
const FIELD_OF_STUDY_PREFIXES: [&str; 3] = ["101", "102", "103"];
@ -60,7 +60,7 @@ impl ApplicationService {
let application = Mutation::create_application(
db,
application_id,
candidate.application,
candidate.id,
hashed_password,
enc_personal_id_number.to_string(),
pubkey,
@ -87,8 +87,8 @@ impl ApplicationService {
personal_id_number: String,
) -> Result<(application::Model, candidate::Model, parent::Model), ServiceError> {
let candidate = CandidateService::create(db, personal_id_number).await?;
let parent = ParentService::create(db, candidate.application).await?;
let application = Mutation::update_candidate_fk(db, application, candidate.application).await?;
let parent = ParentService::create(db, candidate.id).await?;
let application = Mutation::update_candidate_fk(db, application, candidate.id).await?;
Ok(
(
application,
@ -141,7 +141,26 @@ impl ApplicationService {
} else {
Err(ServiceError::Forbidden)
}
}
pub async fn list_applications(
private_key: &String,
db: &DbConn,
) -> Result<Vec<ApplicationResponse>, ServiceError> {
let applications = Query::list_applications(db).await?;
futures::future::try_join_all(
applications
.iter()
.map(|c| async move {
ApplicationResponse::from_encrypted(
private_key,
c.to_owned()
).await
})
).await
}
async fn decrypt_private_key(

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

@ -30,14 +30,14 @@ impl CandidateService {
)
.await?;
PortfolioService::create_user_dir(candidate.application).await?;
PortfolioService::create_user_dir(candidate.id).await?;
Ok(candidate)
}
pub async fn delete_candidate(db: &DbConn, candidate: candidate::Model) -> Result<(), ServiceError> {
PortfolioService::delete_candidate_root(candidate.application).await?;
PortfolioService::delete_candidate_root(candidate.id).await?;
Mutation::delete_candidate(db, candidate).await?;
Ok(())

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

@ -32,7 +32,7 @@ impl ParentService {
for i in 0..parents_details.len() {
let found_parent = match found_parents.get(i) {
Some(parent) => parent.to_owned(),
None => ParentService::create(db, ref_candidate.application).await?,
None => ParentService::create(db, ref_candidate.id).await?,
};
let enc_details = EncryptedParentDetails::new(&parents_details[i], recipients).await?;
let parent = Mutation::add_parent_details(db, found_parent, enc_details.clone()).await?;
@ -94,8 +94,8 @@ mod tests {
async fn create_parent_test() {
let db = get_memory_sqlite_connection().await;
let candidate = CandidateService::create(&db, "".to_string()).await.unwrap();
super::ParentService::create(&db, candidate.application).await.unwrap();
super::ParentService::create(&db, candidate.application).await.unwrap();
super::ParentService::create(&db, candidate.id).await.unwrap();
super::ParentService::create(&db, candidate.id).await.unwrap();
}
/* #[tokio::test]

56
core/src/services/portfolio_service.rs
View file

@ -269,7 +269,7 @@ impl PortfolioService {
/// Move files from cache to final directory and delete cache afterwards
pub async fn submit(public_key: &String, candidate: &candidate::Model, db: &DbConn) -> Result<(), ServiceError> {
let candidate_id = candidate.application;
let candidate_id = candidate.id;
let path = Self::get_file_store_path().join(&candidate_id.to_string()).to_path_buf();
let cache_path = path.join("cache");
@ -277,7 +277,7 @@ impl PortfolioService {
return Err(ServiceError::IncompletePortfolio);
}
info!("PORTFOLIO {} SUBMIT STARTED", candidate.application);
info!("PORTFOLIO {} SUBMIT STARTED", candidate.id);
let mut archive = tokio::fs::File::create(path.join(FileType::PortfolioZip.as_str())).await?;
let mut writer = async_zip::write::ZipFileWriter::new(&mut archive);
@ -428,8 +428,8 @@ mod tests {
.ok()
.unwrap();
assert!(tokio::fs::metadata(temp_dir.join(candidate.application.to_string())).await.is_ok());
assert!(tokio::fs::metadata(temp_dir.join(candidate.application.to_string()).join("cache")).await.is_ok());
assert!(tokio::fs::metadata(temp_dir.join(candidate.id.to_string())).await.is_ok());
assert!(tokio::fs::metadata(temp_dir.join(candidate.id.to_string()).join("cache")).await.is_ok());
tokio::fs::remove_dir_all(temp_dir).await.unwrap();
}
@ -621,11 +621,11 @@ mod tests {
let db = get_memory_sqlite_connection().await;
let (application, candidate, _) = put_user_data(&db).await;
let (temp_dir, application_dir, _) = create_data_store_temp_dir(candidate.application).await;
let (temp_dir, application_dir, _) = create_data_store_temp_dir(candidate.id).await;
PortfolioService::add_cover_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_cover_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::submit(&application.public_key, &candidate, &db).await.unwrap();
@ -640,17 +640,17 @@ mod tests {
let db = get_memory_sqlite_connection().await;
let (application, candidate, _) = put_user_data(&db).await;
let (temp_dir, application_dir, _) = create_data_store_temp_dir(candidate.application).await;
let (temp_dir, application_dir, _) = create_data_store_temp_dir(candidate.id).await;
PortfolioService::add_cover_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_cover_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::submit(&application.public_key, &candidate, &db).await.unwrap();
assert!(tokio::fs::metadata(application_dir.join("PORTFOLIO.age")).await.is_ok());
PortfolioService::delete_portfolio(candidate.application).await.unwrap();
PortfolioService::delete_portfolio(candidate.id).await.unwrap();
assert!(!tokio::fs::metadata(application_dir.join("PORTFOLIO.age")).await.is_ok());
@ -663,29 +663,29 @@ mod tests {
let db = get_memory_sqlite_connection().await;
let (application, candidate, _) = put_user_data(&db).await;
let (temp_dir, _, _) = create_data_store_temp_dir(candidate.application).await;
let (temp_dir, _, _) = create_data_store_temp_dir(candidate.id).await;
PortfolioService::add_cover_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_cover_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::submit(&application.public_key, &candidate, &db).await.unwrap();
assert!(PortfolioService::is_portfolio_submitted(candidate.application).await);
assert!(PortfolioService::is_portfolio_submitted(candidate.id).await);
clear_data_store_temp_dir(temp_dir).await;
let (temp_dir, application_dir, _) = create_data_store_temp_dir(candidate.application).await;
let (temp_dir, application_dir, _) = create_data_store_temp_dir(candidate.id).await;
PortfolioService::add_cover_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.application, vec![0]).await.unwrap();
PortfolioService::add_cover_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.id, vec![0]).await.unwrap();
PortfolioService::submit(&application.public_key, &candidate, &db).await.unwrap();
tokio::fs::remove_file(application_dir.join("PORTFOLIO.age")).await.unwrap();
assert!(!PortfolioService::is_portfolio_submitted(candidate.application).await);
assert!(!PortfolioService::is_portfolio_submitted(candidate.id).await);
clear_data_store_temp_dir(temp_dir).await;
}
@ -696,19 +696,19 @@ mod tests {
let db = get_memory_sqlite_connection().await;
let (application, candidate, _parent) = put_user_data(&db).await;
let (temp_dir, _, _) = create_data_store_temp_dir(candidate.application).await;
let (temp_dir, _, _) = create_data_store_temp_dir(candidate.id).await;
let private_key = crypto::decrypt_password(application.private_key.clone(), "test".to_string())
.await
.unwrap();
PortfolioService::add_cover_letter_to_cache(candidate.application, vec![0])
PortfolioService::add_cover_letter_to_cache(candidate.id, vec![0])
.await
.unwrap();
PortfolioService::add_portfolio_letter_to_cache(candidate.application, vec![0])
PortfolioService::add_portfolio_letter_to_cache(candidate.id, vec![0])
.await
.unwrap();
PortfolioService::add_portfolio_zip_to_cache(candidate.application, vec![0])
PortfolioService::add_portfolio_zip_to_cache(candidate.id, vec![0])
.await
.unwrap();
@ -716,7 +716,7 @@ mod tests {
.await
.unwrap();
PortfolioService::get_portfolio(candidate.application, private_key)
PortfolioService::get_portfolio(candidate.id, private_key)
.await
.unwrap();

2
core/src/utils/csv.rs
View file

@ -41,7 +41,7 @@ pub async fn export(
let candidates_with_parents = Query::list_candidates_full(&db).await?;
for candidate in candidates_with_parents {
let application = candidate.application;
let application = candidate.id;
let parents = Query::find_candidate_parents(db, &candidate).await?;
let row: Row = match EncryptedApplicationDetails::try_from((&candidate, parents)) {

2
entity/src/application.rs
View file

@ -21,7 +21,7 @@ pub enum Relation {
#[sea_orm(
belongs_to = "super::candidate::Entity",
from = "Column::CandidateId",
to = "super::candidate::Column::Application",
to = "super::candidate::Column::Id",
on_update = "Cascade",
on_delete = "Cascade"
)]

2
entity/src/candidate.rs
View file

@ -6,7 +6,7 @@ use sea_orm::entity::prelude::*;
#[sea_orm(table_name = "candidate")]
pub struct Model {
#[sea_orm(primary_key)]
pub application: i32,
pub id: i32,
pub name: Option<String>,
pub surname: Option<String>,
pub birth_surname: Option<String>,

2
entity/src/parent.rs
View file

@ -21,7 +21,7 @@ pub enum Relation {
#[sea_orm(
belongs_to = "super::candidate::Entity",
from = "Column::Application",
to = "super::candidate::Column::Application",
to = "super::candidate::Column::Id",
on_update = "Cascade",
on_delete = "Cascade"
)]

4
migration/src/m20221024_121621_create_candidate.rs
View file

@ -12,7 +12,7 @@ impl MigrationTrait for Migration {
.table(Candidate::Table)
.if_not_exists()
.col(
ColumnDef::new(Candidate::Application)
ColumnDef::new(Candidate::Id)
.integer()
.not_null()
.primary_key()
@ -49,7 +49,7 @@ impl MigrationTrait for Migration {
#[derive(Iden)]
pub enum Candidate {
Table,
Application,
Id,
Name,
Surname,
BirthSurname,

2
migration/src/m20221112_112212_create_parent_candidate_fk.rs
View file

@ -11,7 +11,7 @@ impl MigrationTrait for Migration {
manager.create_foreign_key(ForeignKey::create()
.name("candidate_fk")
.from(Parent::Table, Parent::Application)
.to(Candidate::Table, Candidate::Application)
.to(Candidate::Table, Candidate::Id)
.on_delete(ForeignKeyAction::Cascade)
.on_update(ForeignKeyAction::Cascade)
.to_owned()).await

2
migration/src/m20230114_114826_create_application_candidate_fk.rs
View file

@ -11,7 +11,7 @@ impl MigrationTrait for Migration {
manager.create_foreign_key(ForeignKey::create()
.name("candidate_fk")
.from(Application::Table, Application::CandidateId)
.to(Candidate::Table, Candidate::Application)
.to(Candidate::Table, Candidate::Id)
.on_delete(ForeignKeyAction::Cascade)
.on_update(ForeignKeyAction::Cascade)
.to_owned()).await