147 lines
4.4 KiB
Rust
147 lines
4.4 KiB
Rust
use rocket::form::validate::Contains;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::db;
|
|
|
|
use super::course::Course;
|
|
|
|
#[derive(Serialize, Deserialize, Clone, Debug)]
|
|
#[serde(crate = "rocket::serde")]
|
|
/// Represents a single register send by the frontend
|
|
/// to create a new register in the database
|
|
pub struct RegisterCreate {
|
|
person_id: i32,
|
|
course_id: i32,
|
|
/// YYYY-MM-DD
|
|
date: String,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
pub struct Register {
|
|
pub register_id: i32,
|
|
/// Display code, shown on the certificate.
|
|
/// Currently a 4-digit number. After 9999, it will be a 4-digit hex number.
|
|
///
|
|
/// Example: `0322``
|
|
pub register_code: i32,
|
|
/// Date of creation of the register, in YYYY-MM-DD format
|
|
pub register_creation_date: String,
|
|
/// Date shown on the certificate, in YYYY-MM-DD format
|
|
pub register_display_date: String,
|
|
/// Some course's names can be extended with a label.
|
|
/// Points to a custom_label entity
|
|
pub register_custom_label: i32,
|
|
/// Whether this register is a preview of the certificate ("sin firmas")
|
|
pub register_is_preview: bool,
|
|
/// Foreign key to the person table
|
|
pub register_person_id: i32,
|
|
/// Foreign key to the course table
|
|
pub register_course_id: i32,
|
|
}
|
|
|
|
impl RegisterCreate {
|
|
pub async fn create(&self) -> Result<(), sqlx::Error> {
|
|
let db = db();
|
|
|
|
let next_register_code = Self::get_next_register_code(self.course_id).await?;
|
|
|
|
// Current date in YYYY-MM-DD format
|
|
let current_date = chrono::Local::now().format("%Y-%m-%d").to_string();
|
|
|
|
let _ = sqlx::query!(
|
|
"INSERT INTO register (
|
|
register_code,
|
|
register_creation_date,
|
|
register_display_date,
|
|
register_custom_label,
|
|
register_is_preview,
|
|
register_person_id,
|
|
register_course_id
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?)",
|
|
next_register_code,
|
|
current_date,
|
|
self.date,
|
|
1,
|
|
false,
|
|
self.person_id,
|
|
self.course_id
|
|
)
|
|
.execute(db)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
async fn get_next_register_code(course_id: i32) -> Result<i32, sqlx::Error> {
|
|
let db = db();
|
|
|
|
let course_name = Course::get_course_name(course_id).await;
|
|
|
|
// All matpel certs share codes
|
|
let new_max = if course_name.contains("Matpel") {
|
|
let res = sqlx::query!(
|
|
"SELECT MAX(register_code) AS max FROM register
|
|
WHERE register_course_id IN
|
|
(SELECT course_id FROM course WHERE course_name LIKE 'Matpel%')",
|
|
)
|
|
.fetch_one(db)
|
|
.await?;
|
|
|
|
// If there are no registers, the new code will start from 50, as per the requirements
|
|
res.max.unwrap_or(50) + 1
|
|
} else {
|
|
let res = sqlx::query!(
|
|
"SELECT MAX(register_code) AS max FROM register
|
|
WHERE register_course_id = ?",
|
|
course_id
|
|
)
|
|
.fetch_one(db)
|
|
.await?;
|
|
|
|
// If there are no registers, the new code will start from 50, as per the requirements
|
|
res.max.unwrap_or(50) + 1
|
|
};
|
|
|
|
Ok(new_max)
|
|
}
|
|
}
|
|
|
|
impl Register {
|
|
pub async fn get_by_dni(dni: i32) -> Result<Vec<Register>, sqlx::Error> {
|
|
let db = db();
|
|
|
|
let res = sqlx::query!(
|
|
"SELECT * FROM register
|
|
WHERE register_person_id = (SELECT person_id FROM person WHERE person_dni = ?)",
|
|
dni
|
|
)
|
|
.fetch_all(db)
|
|
.await?
|
|
.into_iter()
|
|
.map(|r| Register {
|
|
register_id: r.register_id,
|
|
register_code: r.register_code,
|
|
register_creation_date: r.register_creation_date.format("%Y-%m-%d").to_string(),
|
|
register_display_date: r.register_display_date.format("%Y-%m-%d").to_string(),
|
|
register_custom_label: r.register_custom_label,
|
|
register_is_preview: r.register_is_preview == 1,
|
|
register_person_id: r.register_person_id,
|
|
register_course_id: r.register_course_id,
|
|
})
|
|
.collect();
|
|
|
|
Ok(res)
|
|
}
|
|
|
|
pub async fn delete(register_id: i32) -> Result<(), sqlx::Error> {
|
|
let db = db();
|
|
|
|
let _ = sqlx::query!("DELETE FROM register WHERE register_id = ?", register_id)
|
|
.execute(db)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|