Add more db shite

.cargo/config.toml

@@ -1 +1,2 @@
-DATABASE_URL="postgres://postgres:postgres@127.0.0.1:5432/persmgr""
+[env]
+DATABASE_URL="postgres://postgres:postgres@127.0.0.1:5432/persmgr"

Cargo.lock

@@ -153,6 +153,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "021e862c184ae977658b36c4500f7feac3221ca5da43e3f25bd04ab6c79a29b5"
 dependencies = [
  "axum-core",
+ "axum-macros",
  "bytes",
  "form_urlencoded",
  "futures-util",
@@ -200,6 +201,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "axum-macros"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "604fde5e028fea851ce1d8570bbdc034bec850d157f7569d10f347d06808c05c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "backtrace"
 version = "0.3.75"
@@ -1271,6 +1283,7 @@ dependencies = [
  "askama",
  "axum",
  "base64",
+ "cfg-if",
  "pulldown-cmark",
  "rand 0.9.2",
  "serde",

Cargo.toml

@@ -7,8 +7,9 @@ edition = "2024"
 anyhow = "1.0.99"
 argon2 = { version = "0.5.3", features = ["simple", "std"] }
 askama = "0.14.0"
-axum = "0.8.4"
+axum = { version = "0.8.4", features = ["macros"] }
 base64 = "0.22.1"
+cfg-if = "1.0.3"
 pulldown-cmark = "0.13.0"
 rand = "0.9.2"
 serde = { version = "1.0.219", features = ["derive"] }

migrations/20250906104612_users.up.sql

@@ -7,6 +7,7 @@ CREATE TABLE IF NOT EXISTS users (
     username TEXT NOT NULL UNIQUE,
     pw_hash TEXT NOT NULL,
     pw_salt TEXT NOT NULL,
-    pfp_id BIGINT NOT NULL
+    pfp_id BIGINT NOT NULL,
+    rank_id BIGINT NOT NULL
 );
 

migrations/20250906202709_sessions.up.sql

@@ -3,5 +3,6 @@
 CREATE TABLE IF NOT EXISTS sessions (
     user_id BIGINT NOT NULL,
     session_key TEXT NOT NULL UNIQUE,
-    expires BIGINT NOT NULL
+    expires BIGINT NOT NULL,
+    CONSTRAINT fk_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE
 )

migrations/20250913111557_ranks.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS ranks;

migrations/20250913111557_ranks.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS ranks (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL,
+    created_at BIGINT NOT NULL,
+    modified_at BIGINT NOT NULL
+);

migrations/20250913111613_awards.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS awards;

migrations/20250913111613_awards.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS awards (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL,
+    created_at BIGINT NOT NULL,
+    modified_at BIGINT NOT NULL
+);

migrations/20250913111614_trainings.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS trainings;

migrations/20250913111614_trainings.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS trainings (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL,
+    created_at BIGINT NOT NULL,
+    modified_at BIGINT NOT NULL
+);

migrations/20250913111615_missions.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS missions;

migrations/20250913111615_missions.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS missions (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL,
+    created_at BIGINT NOT NULL,
+    modified_at BIGINT NOT NULL
+);

migrations/20250913111617_qualifications.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS qualifications;

migrations/20250913111617_qualifications.up.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS qualifications (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL,
+    created_at BIGINT NOT NULL,
+    modified_at BIGINT NOT NULL
+);

migrations/20250913111736_records_ranks.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS record_ranks;

migrations/20250913111736_records_ranks.up.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS records_ranks (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    user_id BIGINT NOT NULL,
+    rank_id BIGINT NOT NULL,
+    author_id BIGINT NOT NULL,
+    created_at BIGINT NOT NULL,
+
+    CONSTRAINT fk_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT fk_author FOREIGN KEY(author_id) REFERENCES users(id) ON DELETE SET NULL,
+    CONSTRAINT fk_rank FOREIGN KEY (rank_id) REFERENCES ranks(id) ON DELETE CASCADE
+);

migrations/20250913111748_records_awards.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS record_awards;

migrations/20250913111748_records_awards.up.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS records_awards (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    user_id BIGINT NOT NULL,
+    award_id BIGINT NOT NULL,
+    author_id BIGINT NOT NULL,
+    created_at BIGINT NOT NULL,
+
+    CONSTRAINT fk_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT fk_author FOREIGN KEY(author_id) REFERENCES users(id) ON DELETE SET NULL,
+    CONSTRAINT fk_award FOREIGN KEY (award_id) REFERENCES awards(id) ON DELETE CASCADE
+);

migrations/20250913111802_records_training.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS record_training;

migrations/20250913111802_records_training.up.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS records_trainings (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    user_id BIGINT NOT NULL,
+    training_id BIGINT NOT NULL,
+    author_id BIGINT NOT NULL,
+    created_at BIGINT NOT NULL,
+
+    CONSTRAINT fk_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT fk_author FOREIGN KEY(author_id) REFERENCES users(id) ON DELETE SET NULL,
+    CONSTRAINT fk_training FOREIGN KEY (training_id) REFERENCES trainings(id) ON DELETE CASCADE
+);

migrations/20250913111810_records_qualifications.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS record_qualifications;

migrations/20250913111810_records_qualifications.up.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS records_qualifications (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    user_id BIGINT NOT NULL,
+    qualification_id BIGINT NOT NULL,
+    author_id BIGINT NOT NULL,
+    created_at BIGINT NOT NULL,
+
+    CONSTRAINT fk_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT fk_author FOREIGN KEY(author_id) REFERENCES users(id) ON DELETE SET NULL,
+    CONSTRAINT fk_qualification FOREIGN KEY (qualification_id) REFERENCES qualifications(id) ON DELETE CASCADE
+);

migrations/20250913112041_records_missions.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS records_missions;

migrations/20250913112041_records_missions.up.sql

@@ -0,0 +1,11 @@
+CREATE TABLE IF NOT EXISTS records_missions (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    user_id BIGINT NOT NULL,
+    mission_id BIGINT NOT NULL,
+    author_id BIGINT NOT NULL,
+    created_at BIGINT NOT NULL,
+
+    CONSTRAINT fk_user FOREIGN KEY(user_id) REFERENCES users(id) ON DELETE CASCADE,
+    CONSTRAINT fk_author FOREIGN KEY(author_id) REFERENCES users(id) ON DELETE SET NULL,
+    CONSTRAINT fk_mission FOREIGN KEY (mission_id) REFERENCES missions(id) ON DELETE CASCADE
+);

src/api/files/create.rs

@@ -0,0 +1,29 @@
+use axum::{
+    body::{Body, Bytes},
+    extract::{Path, State},
+    http::{HeaderMap, HeaderValue, StatusCode},
+    response::{IntoResponse, Response},
+};
+use serde::Deserialize;
+
+use crate::db::Database;
+
+#[derive(Debug, Deserialize)]
+pub struct Data {
+    path: String,
+}
+
+#[axum::debug_handler]
+pub async fn route(State(db): State<Database>) -> impl IntoResponse {
+    if false {
+        return Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body(String::new())
+            .unwrap();
+    }
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .body(String::new())
+        .unwrap()
+}

src/api/files/delete.rs

@@ -0,0 +1,30 @@
+use axum::{
+    body::{Body, Bytes},
+    extract::{Path, State},
+    http::{HeaderMap, HeaderValue, StatusCode},
+    response::{IntoResponse, Response},
+};
+use serde::Deserialize;
+
+use crate::db::Database;
+
+#[derive(Debug, Deserialize)]
+pub struct Data {
+    id: String,
+}
+
+#[axum::debug_handler]
+pub async fn route(State(db): State<Database>) -> impl IntoResponse {
+    if false {
+        return Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body(String::new())
+            .unwrap();
+    }
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .body(String::new())
+        .unwrap()
+}
+

src/api/files/get_file.rs

@@ -0,0 +1,30 @@
+use axum::{
+    body::{Body, Bytes},
+    extract::{Path, State},
+    http::{HeaderMap, HeaderValue, StatusCode},
+    response::{IntoResponse, Response},
+};
+use serde::Deserialize;
+
+use crate::db::Database;
+
+#[derive(Debug, Deserialize)]
+pub struct Data {
+    id: String,
+}
+
+#[axum::debug_handler]
+pub async fn route(State(db): State<Database>) -> impl IntoResponse {
+    if false {
+        return Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body(String::new())
+            .unwrap();
+    }
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .body(String::new())
+        .unwrap()
+}
+

src/api/files/mkdir.rs

@@ -0,0 +1,30 @@
+use axum::{
+    body::{Body, Bytes},
+    extract::{Path, State},
+    http::{HeaderMap, HeaderValue, StatusCode},
+    response::{IntoResponse, Response},
+};
+use serde::Deserialize;
+
+use crate::db::Database;
+
+#[derive(Debug, Deserialize)]
+pub struct Data {
+    id: String,
+}
+
+#[axum::debug_handler]
+pub async fn route(State(db): State<Database>) -> impl IntoResponse {
+    if false {
+        return Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body(String::new())
+            .unwrap();
+    }
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .body(String::new())
+        .unwrap()
+}
+

src/api/files/mod.rs

@@ -0,0 +1,21 @@
+use axum::{
+    Router,
+    routing::{get, post},
+};
+
+use crate::db::Database;
+
+mod create;
+mod delete;
+mod get_file;
+mod mkdir;
+mod rmdir;
+
+pub fn register_routes() -> Router<Database> {
+    Router::new()
+        .route("/file/upload", post(create::route))
+        .route("/file/get", get(get_file::route))
+        .route("/file/delete", get(delete::route))
+        .route("/dir/create", get(mkdir::route))
+        .route("/dir/remove", get(rmdir::route))
+}

src/api/files/rmdir.rs

@@ -0,0 +1,30 @@
+use axum::{
+    body::{Body, Bytes},
+    extract::{Path, State},
+    http::{HeaderMap, HeaderValue, StatusCode},
+    response::{IntoResponse, Response},
+};
+use serde::Deserialize;
+
+use crate::db::Database;
+
+#[derive(Debug, Deserialize)]
+pub struct Data {
+    id: String,
+}
+
+#[axum::debug_handler]
+pub async fn route(State(db): State<Database>) -> impl IntoResponse {
+    if false {
+        return Response::builder()
+            .status(StatusCode::NOT_FOUND)
+            .body(String::new())
+            .unwrap();
+    }
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .body(String::new())
+        .unwrap()
+}
+

src/api/mod.rs

@@ -1,6 +1,7 @@
 use crate::db::Database;
 use axum::{Router, extract::State, http::StatusCode, routing::get};
 
+pub mod files;
 pub mod user;
 
 async fn root(State(state): State<Database>) -> (StatusCode, &'static str) {
@@ -10,7 +11,8 @@ async fn root(State(state): State<Database>) -> (StatusCode, &'static str) {
 pub fn register_routes() -> Router<Database> {
     let router = Router::new()
         .route("/", get(root))
-        .nest("/user", user::register_routes());
+        .nest("/user", user::register_routes())
+        .nest("/files", files::register_routes());
 
     Router::new().nest("/api", router)
 }

src/db/tables/assignables/awards.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct Award {
+    pub id: i64,
+    pub name: String,
+    pub description: String,
+    pub created_at: i64,
+    pub modified_at: i64,
+}
+
+impl Award {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            Award,
+            r#"
+                INSERT INTO awards (name, description, created_at, modified_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.name,
+            self.description,
+            self.created_at,
+            self.modified_at
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(Award, "SELECT * FROM awards WHERE id = $1", id)
+            .fetch_one(pool)
+            .await?;
+        Ok(session)
+    }
+    pub async fn update(&self, pool: &CurrPool) -> anyhow::Result<Self> {
+        let curr_time = time::OffsetDateTime::now_utc().unix_timestamp();
+        let session = sqlx::query_as!(
+            Award,
+            r#"
+                UPDATE awards SET 
+                name = $2,
+                description = $3,
+                modified_at = $4
+                WHERE id = $1
+                RETURNING *
+                "#,
+            self.id,
+            self.name,
+            self.description,
+            curr_time
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/assignables/missions.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct Mission {
+    pub id: i64,
+    pub name: String,
+    pub description: String,
+    pub created_at: i64,
+    pub modified_at: i64,
+}
+
+impl Mission {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            Mission,
+            r#"
+                INSERT INTO missions (name, description, created_at, modified_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.name,
+            self.description,
+            self.created_at,
+            self.modified_at
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(Mission, "SELECT * FROM missions WHERE id = $1", id)
+            .fetch_one(pool)
+            .await?;
+        Ok(session)
+    }
+    pub async fn update(&self, pool: &CurrPool) -> anyhow::Result<Self> {
+        let curr_time = time::OffsetDateTime::now_utc().unix_timestamp();
+        let session = sqlx::query_as!(
+            Mission,
+            r#"
+                UPDATE missions SET 
+                name = $2,
+                description = $3,
+                modified_at = $4
+                WHERE id = $1
+                RETURNING *
+                "#,
+            self.id,
+            self.name,
+            self.description,
+            curr_time
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/assignables/mod.rs

@@ -0,0 +1,5 @@
+pub mod awards;
+pub mod missions;
+pub mod qualifications;
+pub mod ranks;
+pub mod trainings;

src/db/tables/assignables/qualifications.rs

@@ -0,0 +1,64 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct Qualification {
+    pub id: i64,
+    pub name: String,
+    pub description: String,
+    pub created_at: i64,
+    pub modified_at: i64,
+}
+
+impl Qualification {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            Qualification,
+            r#"
+                INSERT INTO qualifications (name, description, created_at, modified_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.name,
+            self.description,
+            self.created_at,
+            self.modified_at
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(
+            Qualification,
+            "SELECT * FROM qualifications WHERE id = $1",
+            id
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn update(&self, pool: &CurrPool) -> anyhow::Result<Self> {
+        let curr_time = time::OffsetDateTime::now_utc().unix_timestamp();
+        let session = sqlx::query_as!(
+            Qualification,
+            r#"
+                UPDATE qualifications SET 
+                name = $2,
+                description = $3,
+                modified_at = $4
+                WHERE id = $1
+                RETURNING *
+                "#,
+            self.id,
+            self.name,
+            self.description,
+            curr_time
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/assignables/ranks.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct Rank {
+    pub id: i64,
+    pub name: String,
+    pub description: String,
+    pub created_at: i64,
+    pub modified_at: i64,
+}
+
+impl Rank {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            Rank,
+            r#"
+                INSERT INTO ranks (name, description, created_at, modified_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.name,
+            self.description,
+            self.created_at,
+            self.modified_at
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(Rank, "SELECT * FROM ranks WHERE id = $1", id)
+            .fetch_one(pool)
+            .await?;
+        Ok(session)
+    }
+    pub async fn update(&self, pool: &CurrPool) -> anyhow::Result<Self> {
+        let curr_time = time::OffsetDateTime::now_utc().unix_timestamp();
+        let session = sqlx::query_as!(
+            Rank,
+            r#"
+                UPDATE ranks SET 
+                name = $2,
+                description = $3,
+                modified_at = $4
+                WHERE id = $1
+                RETURNING *
+                "#,
+            self.id,
+            self.name,
+            self.description,
+            curr_time
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/assignables/trainings.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct Training {
+    pub id: i64,
+    pub name: String,
+    pub description: String,
+    pub created_at: i64,
+    pub modified_at: i64,
+}
+
+impl Training {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            Training,
+            r#"
+                INSERT INTO trainings (name, description, created_at, modified_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.name,
+            self.description,
+            self.created_at,
+            self.modified_at
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(Training, "SELECT * FROM trainings WHERE id = $1", id)
+            .fetch_one(pool)
+            .await?;
+        Ok(session)
+    }
+    pub async fn update(&self, pool: &CurrPool) -> anyhow::Result<Self> {
+        let curr_time = time::OffsetDateTime::now_utc().unix_timestamp();
+        let session = sqlx::query_as!(
+            Training,
+            r#"
+                UPDATE trainings SET 
+                name = $2,
+                description = $3,
+                modified_at = $4
+                WHERE id = $1
+                RETURNING *
+                "#,
+            self.id,
+            self.name,
+            self.description,
+            curr_time
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/mod.rs

@@ -1,2 +1,4 @@
+pub mod assignables;
+pub mod records;
 pub mod sessions;
 pub mod user;

src/db/tables/records/awards.rs

@@ -0,0 +1,73 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct AwardRecord {
+    pub id: i64,
+    pub user_id: i64,
+    pub award_id: i64,
+    pub author_id: i64,
+    pub created_at: i64,
+}
+
+impl AwardRecord {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            AwardRecord,
+            r#"
+                INSERT INTO records_awards (user_id, award_id, author_id, created_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.user_id,
+            self.award_id,
+            self.author_id,
+            self.created_at,
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(
+            AwardRecord,
+            "SELECT * FROM records_awards WHERE id = $1",
+            id
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_user_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            AwardRecord,
+            "SELECT * FROM records_awards WHERE user_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_author_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            AwardRecord,
+            "SELECT * FROM records_awards WHERE author_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_award_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            AwardRecord,
+            "SELECT * FROM records_awards WHERE award_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/records/missions.rs

@@ -0,0 +1,73 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct MissionRecord {
+    pub id: i64,
+    pub user_id: i64,
+    pub mission_id: i64,
+    pub author_id: i64,
+    pub created_at: i64,
+}
+
+impl MissionRecord {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            MissionRecord,
+            r#"
+                INSERT INTO records_missions (user_id, mission_id, author_id, created_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.user_id,
+            self.mission_id,
+            self.author_id,
+            self.created_at,
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(
+            MissionRecord,
+            "SELECT * FROM records_missions WHERE id = $1",
+            id
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_user_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            MissionRecord,
+            "SELECT * FROM records_missions WHERE user_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_author_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            MissionRecord,
+            "SELECT * FROM records_missions WHERE author_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_mission_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            MissionRecord,
+            "SELECT * FROM records_missions WHERE mission_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/records/mod.rs

@@ -0,0 +1,5 @@
+pub mod awards;
+pub mod missions;
+pub mod qualifications;
+pub mod ranks;
+pub mod trainings;

src/db/tables/records/qualifications.rs

@@ -0,0 +1,73 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct QualificationRecord {
+    pub id: i64,
+    pub user_id: i64,
+    pub qualification_id: i64,
+    pub author_id: i64,
+    pub created_at: i64,
+}
+
+impl QualificationRecord {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            QualificationRecord,
+            r#"
+                INSERT INTO records_qualifications (user_id, qualification_id, author_id, created_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.user_id,
+            self.qualification_id,
+            self.author_id,
+            self.created_at,
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(
+            QualificationRecord,
+            "SELECT * FROM records_qualifications WHERE id = $1",
+            id
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_user_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            QualificationRecord,
+            "SELECT * FROM records_qualifications WHERE user_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_author_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            QualificationRecord,
+            "SELECT * FROM records_qualifications WHERE author_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_qualification_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            QualificationRecord,
+            "SELECT * FROM records_qualifications WHERE qualification_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/records/ranks.rs

@@ -0,0 +1,69 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct RankRecord {
+    pub id: i64,
+    pub user_id: i64,
+    pub rank_id: i64,
+    pub author_id: i64,
+    pub created_at: i64,
+}
+
+impl RankRecord {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            RankRecord,
+            r#"
+                INSERT INTO records_ranks (user_id, rank_id, author_id, created_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.user_id,
+            self.rank_id,
+            self.author_id,
+            self.created_at,
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(RankRecord, "SELECT * FROM records_ranks WHERE id = $1", id)
+            .fetch_one(pool)
+            .await?;
+        Ok(session)
+    }
+    pub async fn get_by_user_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            RankRecord,
+            "SELECT * FROM records_ranks WHERE user_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_author_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            RankRecord,
+            "SELECT * FROM records_ranks WHERE author_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_rank_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            RankRecord,
+            "SELECT * FROM records_ranks WHERE rank_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+}

src/db/tables/records/trainings.rs

@@ -0,0 +1,73 @@
+use anyhow::Result;
+
+use crate::db::CurrPool;
+
+#[derive(Debug, Default, Clone)]
+pub struct TrainingRecord {
+    pub id: i64,
+    pub user_id: i64,
+    pub training_id: i64,
+    pub author_id: i64,
+    pub created_at: i64,
+}
+
+impl TrainingRecord {
+    pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
+        let session = sqlx::query_as!(
+            TrainingRecord,
+            r#"
+                INSERT INTO records_trainings (user_id, training_id, author_id, created_at)
+                VALUES ($1, $2, $3, $4)
+                RETURNING *
+            "#,
+            self.user_id,
+            self.training_id,
+            self.author_id,
+            self.created_at,
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(session)
+    }
+    pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {
+        let session = sqlx::query_as!(
+            TrainingRecord,
+            "SELECT * FROM records_trainings WHERE id = $1",
+            id
+        )
+        .fetch_one(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_user_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            TrainingRecord,
+            "SELECT * FROM records_trainings WHERE user_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_author_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            TrainingRecord,
+            "SELECT * FROM records_trainings WHERE author_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+    pub async fn get_by_training_id(pool: &CurrPool, id: i64) -> anyhow::Result<Vec<Self>> {
+        let session = sqlx::query_as!(
+            TrainingRecord,
+            "SELECT * FROM records_trainings WHERE training_id = $1",
+            id
+        )
+        .fetch_all(pool)
+        .await?;
+        Ok(session)
+    }
+}