ChipsEater/Polevoy_SUBD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ChipsEater:05f84c134e4abde869a148d3c2162d4f666d626d
Branches Tags
ChipsEater:main
ChipsEater:frontend
ChipsEater:backend
..
compare: ChipsEater:f7eb534027eee9981af81630b704f98cad6ca1fd
Branches Tags
ChipsEater:main
ChipsEater:frontend
ChipsEater:backend

No commits in common. "05f84c134e4abde869a148d3c2162d4f666d626d" and "f7eb534027eee9981af81630b704f98cad6ca1fd" have entirely different histories.
05f84c134e ... f7eb534027

27 changed files with 146 additions and 1063 deletions
Show Stats Expand all files Collapse all files

276
backend/Cargo.lock generated
View File

@ -245,12 +245,6 @@ dependencies = [
"libc", "libc",
] ]
[[package]]
name = "arrayvec"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
[[package]] [[package]]
name = "async-trait" name = "async-trait"
version = "0.1.68" version = "0.1.68"
@ -277,13 +271,8 @@ dependencies = [
"chrono", "chrono",
"dotenv", "dotenv",
"dotenv_codegen", "dotenv_codegen",
"nanoid",
"pbkdf2",
"rust_decimal",
"rust_decimal_macros",
"serde", "serde",
"serde_json", "serde_json",
"sha2",
"tokio", "tokio",
"tokio-postgres", "tokio-postgres",
] ]
@ -300,18 +289,6 @@ version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "bitvec"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
dependencies = [
"funty",
"radium",
"tap",
"wyz",
]
[[package]] [[package]]
name = "block-buffer" name = "block-buffer"
version = "0.10.4" version = "0.10.4"
@ -321,51 +298,6 @@ dependencies = [
"generic-array", "generic-array",
] ]
[[package]]
name = "borsh"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4114279215a005bc675e386011e594e1d9b800918cea18fcadadcce864a2046b"
dependencies = [
"borsh-derive",
"hashbrown",
]
[[package]]
name = "borsh-derive"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0754613691538d51f329cce9af41d7b7ca150bc973056f1156611489475f54f7"
dependencies = [
"borsh-derive-internal",
"borsh-schema-derive-internal",
"proc-macro-crate",
"proc-macro2",
"syn 1.0.109",
]
[[package]]
name = "borsh-derive-internal"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "afb438156919598d2c7bad7e1c0adf3d26ed3840dbc010db1a882a65583ca2fb"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]]
name = "borsh-schema-derive-internal"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "634205cc43f74a1b9046ef87c4540ebda95696ec0f315024860cad7c5b0f5ccd"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]] [[package]]
name = "brotli" name = "brotli"
version = "3.3.4" version = "3.3.4"
@ -393,28 +325,6 @@ version = "3.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535" checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
[[package]]
name = "bytecheck"
version = "0.6.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b6372023ac861f6e6dc89c8344a8f398fb42aaba2b5dbc649ca0c0e9dbcb627"
dependencies = [
"bytecheck_derive",
"ptr_meta",
"simdutf8",
]
[[package]]
name = "bytecheck_derive"
version = "0.6.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7ec4c6f261935ad534c0c22dbef2201b45918860eb1c574b972bd213a76af61"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]] [[package]]
name = "byteorder" name = "byteorder"
version = "1.4.3" version = "1.4.3"
@ -665,12 +575,6 @@ dependencies = [
"percent-encoding", "percent-encoding",
] ]
[[package]]
name = "funty"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]] [[package]]
name = "futures-channel" name = "futures-channel"
version = "0.3.28" version = "0.3.28"
@ -770,9 +674,6 @@ name = "hashbrown"
version = "0.12.3" version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
dependencies = [
"ahash 0.7.6",
]
[[package]] [[package]]
name = "hermit-abi" name = "hermit-abi"
@ -983,15 +884,6 @@ dependencies = [
"windows-sys", "windows-sys",
] ]
[[package]]
name = "nanoid"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ffa00dec017b5b1a8b7cf5e2c008bfda1aa7e0697ac1508b491fdf2622fb4d8"
dependencies = [
"rand",
]
[[package]] [[package]]
name = "num-integer" name = "num-integer"
version = "0.1.45" version = "0.1.45"
@ -1056,16 +948,6 @@ version = "1.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f746c4065a8fa3fe23974dd82f15431cc8d40779821001404d10d2e79ca7d79" checksum = "9f746c4065a8fa3fe23974dd82f15431cc8d40779821001404d10d2e79ca7d79"
[[package]]
name = "pbkdf2"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0ca0b5a68607598bf3bad68f32227a8164f6254833f84eafaac409cd6746c31"
dependencies = [
"digest",
"hmac",
]
[[package]] [[package]]
name = "percent-encoding" name = "percent-encoding"
version = "2.2.0" version = "2.2.0"
@ -1108,20 +990,6 @@ version = "0.3.26"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160" checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
[[package]]
name = "postgres"
version = "0.19.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0bed5017bc2ff49649c0075d0d7a9d676933c1292480c1d137776fb205b5cd18"
dependencies = [
"bytes",
"fallible-iterator",
"futures-util",
"log",
"tokio",
"tokio-postgres",
]
[[package]] [[package]]
name = "postgres-protocol" name = "postgres-protocol"
version = "0.6.5" version = "0.6.5"
@ -1158,15 +1026,6 @@ version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
[[package]]
name = "proc-macro-crate"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d6ea3c4595b96363c13943497db34af4460fb474a95c43f4446ad341b8c9785"
dependencies = [
"toml",
]
[[package]] [[package]]
name = "proc-macro-hack" name = "proc-macro-hack"
version = "0.5.20+deprecated" version = "0.5.20+deprecated"
@ -1182,26 +1041,6 @@ dependencies = [
"unicode-ident", "unicode-ident",
] ]
[[package]]
name = "ptr_meta"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
dependencies = [
"ptr_meta_derive",
]
[[package]]
name = "ptr_meta_derive"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]] [[package]]
name = "quote" name = "quote"
version = "1.0.26" version = "1.0.26"
@ -1211,12 +1050,6 @@ dependencies = [
"proc-macro2", "proc-macro2",
] ]
[[package]]
name = "radium"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
[[package]] [[package]]
name = "rand" name = "rand"
version = "0.8.5" version = "0.8.5"
@ -1273,73 +1106,6 @@ version = "0.6.29"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
[[package]]
name = "rend"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "581008d2099240d37fb08d77ad713bcaec2c4d89d50b5b21a8bb1996bbab68ab"
dependencies = [
"bytecheck",
]
[[package]]
name = "rkyv"
version = "0.7.42"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0200c8230b013893c0b2d6213d6ec64ed2b9be2e0e016682b7224ff82cff5c58"
dependencies = [
"bitvec",
"bytecheck",
"hashbrown",
"ptr_meta",
"rend",
"rkyv_derive",
"seahash",
"tinyvec",
"uuid",
]
[[package]]
name = "rkyv_derive"
version = "0.7.42"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2e06b915b5c230a17d7a736d1e2e63ee753c256a8614ef3f5147b13a4f5541d"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]]
name = "rust_decimal"
version = "1.29.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26bd36b60561ee1fb5ec2817f198b6fd09fa571c897a5e86d1487cfc2b096dfc"
dependencies = [
"arrayvec",
"borsh",
"bytecheck",
"byteorder",
"bytes",
"num-traits",
"postgres",
"rand",
"rkyv",
"serde",
"serde_json",
"tokio-postgres",
]
[[package]]
name = "rust_decimal_macros"
version = "1.29.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e773fd3da1ed42472fdf3cfdb4972948a555bc3d73f5e0bdb99d17e7b54c687"
dependencies = [
"quote",
"rust_decimal",
]
[[package]] [[package]]
name = "rustc_version" name = "rustc_version"
version = "0.4.0" version = "0.4.0"
@ -1367,12 +1133,6 @@ version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1" checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1"
[[package]]
name = "seahash"
version = "4.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
[[package]] [[package]]
name = "semver" name = "semver"
version = "1.0.17" version = "1.0.17"
@ -1453,12 +1213,6 @@ dependencies = [
"libc", "libc",
] ]
[[package]]
name = "simdutf8"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a"
[[package]] [[package]]
name = "siphasher" name = "siphasher"
version = "0.3.10" version = "0.3.10"
@ -1538,12 +1292,6 @@ dependencies = [
"unicode-ident", "unicode-ident",
] ]
[[package]]
name = "tap"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
[[package]] [[package]]
name = "termcolor" name = "termcolor"
version = "1.2.0" version = "1.2.0"
@ -1674,15 +1422,6 @@ dependencies = [
"tracing", "tracing",
] ]
[[package]]
name = "toml"
version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
dependencies = [
"serde",
]
[[package]] [[package]]
name = "tracing" name = "tracing"
version = "0.1.37" version = "0.1.37"
@ -1748,12 +1487,6 @@ dependencies = [
"percent-encoding", "percent-encoding",
] ]
[[package]]
name = "uuid"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4dad5567ad0cf5b760e5665964bec1b47dfd077ba8a2544b513f3556d3d239a2"
[[package]] [[package]]
name = "version_check" name = "version_check"
version = "0.9.4" version = "0.9.4"
@ -1932,15 +1665,6 @@ version = "0.42.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
[[package]]
name = "wyz"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
dependencies = [
"tap",
]
[[package]] [[package]]
name = "zstd" name = "zstd"
version = "0.12.3+zstd.1.5.2" version = "0.12.3+zstd.1.5.2"

5
backend/Cargo.toml
View File

@ -15,8 +15,3 @@ serde_json = "1.0"
serde = { version = "1.0.159", features = ["derive"] } serde = { version = "1.0.159", features = ["derive"] }
async-trait = "0.1.68" async-trait = "0.1.68"
dotenv_codegen = "0.15.0" dotenv_codegen = "0.15.0"
pbkdf2 = "0.12.1"
nanoid = "0.4.0"
sha2 = "0.10.6"
rust_decimal = { version = "1.29", features = ["db-tokio-postgres"] }
rust_decimal_macros = "1.29"

29
backend/src/endpoints/auth.rs
View File

@ -1,29 +0,0 @@
use std::sync::Mutex;
use actix_web::{web, post, Responder, HttpResponse};
use serde_json::json;
use crate::{State, models::administrator};
#[derive(serde::Deserialize)]
pub struct LoginInfo {
username: String,
password: String
}
#[post("/login")]
pub async fn login(state: web::Data<Mutex<State>>, json: web::Json<LoginInfo>) -> impl Responder {
match state.lock() {
Ok(guard) => match guard.auth_service.login(guard.administrator_repository.as_ref(), &json.username, &json.password).await {
Ok((token, administrator_id, car_station_id)) => HttpResponse::Ok().json(json!({"token": token, "administrator_id": administrator_id, "car_station_id": car_station_id}) ),
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
},
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
}
}
#[post("/logout")]
pub async fn logout(state: web::Data<Mutex<State>>, json: web::Json<String>) -> impl Responder {
match state.lock() {
Ok(guard) => { guard.auth_service.logout(&json.0); HttpResponse::Ok().body("Success") },
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
}
}

14
backend/src/endpoints/benchmark.rs
View File

@ -1,14 +0,0 @@
use std::sync::Mutex;
use actix_web::{web, get, post, patch, delete, Responder, HttpResponse, HttpRequest};
use crate::State;
#[get("/benchmark")]
async fn benchmark(state: web::Data<Mutex<State>>) -> impl Responder {
match state.lock() {
Ok(guard) => match guard.benchmark_repository.benchmark().await {
Ok(result) => HttpResponse::Ok().json(result),
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
},
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
}
}

95
backend/src/endpoints/car.rs
View File

@ -1,22 +1,10 @@
use std::sync::Mutex; use std::sync::Mutex;
use crate::models::car::*; use crate::models::car::*;
use actix_web::{web, get, post, patch, delete, Responder, HttpResponse, HttpRequest}; use actix_web::{web, get, post, patch, delete, Responder, HttpResponse};
use crate::State; use crate::State;
#[get("/")] #[get("/")]
pub async fn get_cars(state: web::Data<Mutex<State>>, request: HttpRequest) -> impl Responder { pub async fn get_cars(state: web::Data<Mutex<State>>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_repository.read_all().await { Ok(guard) => match guard.car_repository.read_all().await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -27,19 +15,7 @@ pub async fn get_cars(state: web::Data<Mutex<State>>, request: HttpRequest) -> i
} }
#[get("/{id}")] #[get("/{id}")]
pub async fn get_car(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn get_car(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_repository.read(path.into_inner().0).await { Ok(guard) => match guard.car_repository.read(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -50,19 +26,7 @@ pub async fn get_car(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, r
} }
#[post("/")] #[post("/")]
pub async fn create_car(state: web::Data<Mutex<State>>, json: web::Json<BindingCar>, request: HttpRequest) -> impl Responder { pub async fn create_car(state: web::Data<Mutex<State>>, json: web::Json<BindingCar>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_repository.create(json.0).await { Ok(guard) => match guard.car_repository.create(json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -73,19 +37,7 @@ pub async fn create_car(state: web::Data<Mutex<State>>, json: web::Json<BindingC
} }
#[patch("/{id}")] #[patch("/{id}")]
pub async fn update_car(state: web::Data<Mutex<State>>, json: web::Json<BindingCar>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn update_car(state: web::Data<Mutex<State>>, json: web::Json<BindingCar>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_repository.update(path.into_inner().0, json.0).await { Ok(guard) => match guard.car_repository.update(path.into_inner().0, json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -96,19 +48,7 @@ pub async fn update_car(state: web::Data<Mutex<State>>, json: web::Json<BindingC
} }
#[delete("/{id}")] #[delete("/{id}")]
pub async fn delete_car(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn delete_car(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_repository.delete(path.into_inner().0).await { Ok(guard) => match guard.car_repository.delete(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -117,26 +57,3 @@ pub async fn delete_car(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>
Err(error) => HttpResponse::InternalServerError().json(error.to_string()) Err(error) => HttpResponse::InternalServerError().json(error.to_string())
} }
} }
#[get("/report")]
pub async fn get_report(state: web::Data<Mutex<State>>, request: HttpRequest) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() {
Ok(guard) => match guard.car_repository.get_report().await {
Ok(result) => HttpResponse::Ok().json(result),
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
},
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
}
}

72
backend/src/endpoints/car_station.rs
View File

@ -1,22 +1,10 @@
use std::sync::Mutex; use std::sync::Mutex;
use crate::models::car_station::*; use crate::models::car_station::*;
use actix_web::{web, get, post, patch, delete, Responder, HttpResponse, HttpRequest}; use actix_web::{web, get, post, patch, delete, Responder, HttpResponse};
use crate::State; use crate::State;
#[get("/")] #[get("/")]
pub async fn get_car_stations(state: web::Data<Mutex<State>>, request: HttpRequest) -> impl Responder { pub async fn get_car_stations(state: web::Data<Mutex<State>>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_station_repository.read_all().await { Ok(guard) => match guard.car_station_repository.read_all().await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -27,19 +15,7 @@ pub async fn get_car_stations(state: web::Data<Mutex<State>>, request: HttpReque
} }
#[get("/{id}")] #[get("/{id}")]
pub async fn get_car_station(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn get_car_station(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_station_repository.read(path.into_inner().0).await { Ok(guard) => match guard.car_station_repository.read(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -50,19 +26,7 @@ pub async fn get_car_station(state: web::Data<Mutex<State>>, path: web::Path<(i3
} }
#[post("/")] #[post("/")]
pub async fn create_car_station(state: web::Data<Mutex<State>>, json: web::Json<BindingCarStation>, request: HttpRequest) -> impl Responder { pub async fn create_car_station(state: web::Data<Mutex<State>>, json: web::Json<BindingCarStation>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_station_repository.create(json.0).await { Ok(guard) => match guard.car_station_repository.create(json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -73,19 +37,7 @@ pub async fn create_car_station(state: web::Data<Mutex<State>>, json: web::Json<
} }
#[patch("/{id}")] #[patch("/{id}")]
pub async fn update_car_station(state: web::Data<Mutex<State>>, json: web::Json<BindingCarStation>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn update_car_station(state: web::Data<Mutex<State>>, json: web::Json<BindingCarStation>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_station_repository.update(path.into_inner().0, json.0).await { Ok(guard) => match guard.car_station_repository.update(path.into_inner().0, json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -96,19 +48,7 @@ pub async fn update_car_station(state: web::Data<Mutex<State>>, json: web::Json<
} }
#[delete("/{id}")] #[delete("/{id}")]
pub async fn delete_car_station(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn delete_car_station(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.car_station_repository.delete(path.into_inner().0).await { Ok(guard) => match guard.car_station_repository.delete(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),

72
backend/src/endpoints/client.rs
View File

@ -1,22 +1,10 @@
use std::sync::Mutex; use std::sync::Mutex;
use crate::models::client::*; use crate::models::client::*;
use actix_web::{web, get, post, patch, delete, Responder, HttpResponse, HttpRequest}; use actix_web::{web, get, post, patch, delete, Responder, HttpResponse};
use crate::State; use crate::State;
#[get("/")] #[get("/")]
pub async fn get_clients(state: web::Data<Mutex<State>>, request: HttpRequest) -> impl Responder { pub async fn get_clients(state: web::Data<Mutex<State>>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.client_repository.read_all().await { Ok(guard) => match guard.client_repository.read_all().await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -27,19 +15,7 @@ pub async fn get_clients(state: web::Data<Mutex<State>>, request: HttpRequest) -
} }
#[get("/{id}")] #[get("/{id}")]
pub async fn get_client(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn get_client(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.client_repository.read(path.into_inner().0).await { Ok(guard) => match guard.client_repository.read(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -50,19 +26,7 @@ pub async fn get_client(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>
} }
#[post("/")] #[post("/")]
pub async fn create_client(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>, request: HttpRequest) -> impl Responder { pub async fn create_client(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.client_repository.create(json.0).await { Ok(guard) => match guard.client_repository.create(json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -73,19 +37,7 @@ pub async fn create_client(state: web::Data<Mutex<State>>, json: web::Json<Bindi
} }
#[patch("/{id}")] #[patch("/{id}")]
pub async fn update_client(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn update_client(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.client_repository.update(path.into_inner().0, json.0).await { Ok(guard) => match guard.client_repository.update(path.into_inner().0, json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -96,19 +48,7 @@ pub async fn update_client(state: web::Data<Mutex<State>>, json: web::Json<Bindi
} }
#[delete("/{id}")] #[delete("/{id}")]
pub async fn delete_client(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn delete_client(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.client_repository.delete(path.into_inner().0).await { Ok(guard) => match guard.client_repository.delete(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),

2
backend/src/endpoints/mod.rs
View File

@ -3,5 +3,3 @@ pub mod car_station;
pub mod car; pub mod car;
pub mod rent; pub mod rent;
pub mod owner; pub mod owner;
pub mod auth;
pub mod benchmark;

72
backend/src/endpoints/owner.rs
View File

@ -1,22 +1,10 @@
use std::sync::Mutex; use std::sync::Mutex;
use crate::models::client::*; use crate::models::client::*;
use actix_web::{web, get, post, patch, delete, Responder, HttpResponse, HttpRequest}; use actix_web::{web, get, post, patch, delete, Responder, HttpResponse};
use crate::State; use crate::State;
#[get("/")] #[get("/")]
pub async fn get_owners(state: web::Data<Mutex<State>>, request: HttpRequest) -> impl Responder { pub async fn get_owners(state: web::Data<Mutex<State>>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.owner_repository.read_all().await { Ok(guard) => match guard.owner_repository.read_all().await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -27,19 +15,7 @@ pub async fn get_owners(state: web::Data<Mutex<State>>, request: HttpRequest) ->
} }
#[get("/{id}")] #[get("/{id}")]
pub async fn get_owner(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn get_owner(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.owner_repository.read(path.into_inner().0).await { Ok(guard) => match guard.owner_repository.read(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -50,19 +26,7 @@ pub async fn get_owner(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>,
} }
#[post("/")] #[post("/")]
pub async fn create_owner(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>, request: HttpRequest) -> impl Responder { pub async fn create_owner(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.owner_repository.create(json.0).await { Ok(guard) => match guard.owner_repository.create(json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -73,19 +37,7 @@ pub async fn create_owner(state: web::Data<Mutex<State>>, json: web::Json<Bindin
} }
#[patch("/{id}")] #[patch("/{id}")]
pub async fn update_owner(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn update_owner(state: web::Data<Mutex<State>>, json: web::Json<BindingClient>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.owner_repository.update(path.into_inner().0, json.0).await { Ok(guard) => match guard.owner_repository.update(path.into_inner().0, json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -96,19 +48,7 @@ pub async fn update_owner(state: web::Data<Mutex<State>>, json: web::Json<Bindin
} }
#[delete("/{id}")] #[delete("/{id}")]
pub async fn delete_owner(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn delete_owner(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.owner_repository.delete(path.into_inner().0).await { Ok(guard) => match guard.owner_repository.delete(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),

95
backend/src/endpoints/rent.rs
View File

@ -1,22 +1,10 @@
use std::sync::Mutex; use std::sync::Mutex;
use crate::models::rent::*; use crate::models::rent::*;
use actix_web::{web, get, post, patch, delete, Responder, HttpResponse, HttpRequest}; use actix_web::{web, get, post, patch, delete, Responder, HttpResponse};
use crate::State; use crate::State;
#[get("/")] #[get("/")]
pub async fn get_rents(state: web::Data<Mutex<State>>, request: HttpRequest) -> impl Responder { pub async fn get_rents(state: web::Data<Mutex<State>>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.rent_repository.read_all().await { Ok(guard) => match guard.rent_repository.read_all().await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -27,19 +15,7 @@ pub async fn get_rents(state: web::Data<Mutex<State>>, request: HttpRequest) ->
} }
#[get("/{id}")] #[get("/{id}")]
pub async fn get_rent(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn get_rent(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.rent_repository.read(path.into_inner().0).await { Ok(guard) => match guard.rent_repository.read(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -50,19 +26,7 @@ pub async fn get_rent(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>,
} }
#[post("/")] #[post("/")]
pub async fn create_rent(state: web::Data<Mutex<State>>, json: web::Json<BindingRent>, request: HttpRequest) -> impl Responder { pub async fn create_rent(state: web::Data<Mutex<State>>, json: web::Json<BindingRent>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.rent_repository.create(json.0).await { Ok(guard) => match guard.rent_repository.create(json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -73,19 +37,7 @@ pub async fn create_rent(state: web::Data<Mutex<State>>, json: web::Json<Binding
} }
#[patch("/{id}")] #[patch("/{id}")]
pub async fn update_rent(state: web::Data<Mutex<State>>, json: web::Json<BindingRent>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn update_rent(state: web::Data<Mutex<State>>, json: web::Json<BindingRent>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.rent_repository.update(path.into_inner().0, json.0).await { Ok(guard) => match guard.rent_repository.update(path.into_inner().0, json.0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -96,19 +48,7 @@ pub async fn update_rent(state: web::Data<Mutex<State>>, json: web::Json<Binding
} }
#[delete("/{id}")] #[delete("/{id}")]
pub async fn delete_rent(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder { pub async fn delete_rent(state: web::Data<Mutex<State>>, path: web::Path<(u32, )>) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() { match state.lock() {
Ok(guard) => match guard.rent_repository.delete(path.into_inner().0).await { Ok(guard) => match guard.rent_repository.delete(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result), Ok(result) => HttpResponse::Ok().json(result),
@ -117,26 +57,3 @@ pub async fn delete_rent(state: web::Data<Mutex<State>>, path: web::Path<(i32, )
Err(error) => HttpResponse::InternalServerError().json(error.to_string()) Err(error) => HttpResponse::InternalServerError().json(error.to_string())
} }
} }
#[get("/{id}/end")]
pub async fn end_rent(state: web::Data<Mutex<State>>, path: web::Path<(i32, )>, request: HttpRequest) -> impl Responder {
let token = request.headers().get("Authorization");
if token.is_none() {
return HttpResponse::Unauthorized().body("There is no token");
}
let token = token.unwrap();
if let Ok(guard) = state.lock() {
if guard.auth_service.administrator_by_token(guard.administrator_repository.as_ref(), token.to_str().unwrap()).await.is_err() {
return HttpResponse::Unauthorized().body("Invalid token");
}
}
match state.lock() {
Ok(guard) => match guard.rent_repository.end_rent(path.into_inner().0).await {
Ok(result) => HttpResponse::Ok().json(result),
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
},
Err(error) => HttpResponse::InternalServerError().json(error.to_string())
}
}

9
backend/src/lib.rs
View File

@ -1,20 +1,15 @@
use services::auth::AuthService; use storages::traits::OwnerRepository;
use storages::traits::{OwnerRepository, AdministratorRepository, BenchmarkRepository};
use crate::storages::traits::{CarRepository, CarStationRepository, ClientRepository, RentRepository}; use crate::storages::traits::{CarRepository, CarStationRepository, ClientRepository, RentRepository};
pub mod endpoints; pub mod endpoints;
pub mod models; pub mod models;
pub mod storages; pub mod storages;
pub mod services;
pub struct State { pub struct State {
pub car_repository: Box<dyn CarRepository + Send>, pub car_repository: Box<dyn CarRepository + Send>,
pub car_station_repository: Box<dyn CarStationRepository + Send>, pub car_station_repository: Box<dyn CarStationRepository + Send>,
pub client_repository: Box<dyn ClientRepository + Send>, pub client_repository: Box<dyn ClientRepository + Send>,
pub owner_repository: Box<dyn OwnerRepository + Send>, pub owner_repository: Box<dyn OwnerRepository + Send>,
pub rent_repository: Box<dyn RentRepository + Send>, pub rent_repository: Box<dyn RentRepository + Send>
pub administrator_repository: Box<dyn AdministratorRepository + Send>,
pub benchmark_repository: Box<dyn BenchmarkRepository + Send>,
pub auth_service: AuthService
} }

105
backend/src/main.rs
View File

@ -1,18 +1,14 @@
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
use actix_web::{App, HttpServer, web}; use actix_web::{App, HttpServer, web};
use actix_web::web::Data; use actix_web::web::Data;
use backend::endpoints::benchmark::benchmark;
use backend::endpoints::{auth::*};
use backend::storages::postgres::administrator::PostgresAdministratorRepository;
use dotenv_codegen::dotenv; use dotenv_codegen::dotenv;
use backend::{State, services}; use backend::State;
use tokio_postgres::NoTls; use tokio_postgres::NoTls;
use backend::storages::postgres::car::PostgresCarRepository; use backend::storages::postgres::car::PostgresCarRepository;
use backend::storages::postgres::car_station::PostgresCarStationRepository; use backend::storages::postgres::car_station::PostgresCarStationRepository;
use backend::storages::postgres::client::PostgresClientRepository; use backend::storages::postgres::client::PostgresClientRepository;
use backend::storages::postgres::rent::PostgresRentRepository; use backend::storages::postgres::rent::PostgresRentRepository;
use backend::storages::postgres::owner::PostgresOwnerRepository; use backend::storages::postgres::owner::PostgresOwnerRepository;
use backend::storages::postgres::benchmark::PostgresBenchmarkRepository;
use backend::endpoints::car_station::*; use backend::endpoints::car_station::*;
use backend::endpoints::car::*; use backend::endpoints::car::*;
use backend::endpoints::client::*; use backend::endpoints::client::*;
@ -22,7 +18,7 @@ use backend::endpoints::owner::*;
#[actix_web::main] #[actix_web::main]
async fn main() -> std::io::Result<()> { async fn main() -> std::io::Result<()> {
let (client, connection) = tokio_postgres::connect( let (client, connection) = tokio_postgres::connect(
&format!("host={} user={} password={} dbname={}", dotenv!("HOST"), dotenv!("USER"), dotenv!("PASSWORD"), dotenv!("DBNAMEE")), &format!("host={} user={} password={} dbname={}", dotenv!("HOST"), dotenv!("USER"), dotenv!("PASSWORD"), dotenv!("DBNAME")),
NoTls NoTls
).await.unwrap(); ).await.unwrap();
@ -44,72 +40,57 @@ async fn main() -> std::io::Result<()> {
let rent_repository = PostgresRentRepository { connection: Arc::clone(&client) }; let rent_repository = PostgresRentRepository { connection: Arc::clone(&client) };
let administrator_repository = PostgresAdministratorRepository { connection: Arc::clone(&client) };
let benchmark_repository = PostgresBenchmarkRepository { connection: Arc::clone(&client) };
let auth_service = services::auth::AuthService::new();
let state = Data::new(Mutex::new(State { let state = Data::new(Mutex::new(State {
car_repository: Box::new(car_repository), car_repository: Box::new(car_repository),
car_station_repository: Box::new(car_station_repository), car_station_repository: Box::new(car_station_repository),
client_repository: Box::new(client_repository), client_repository: Box::new(client_repository),
owner_repository: Box::new(owner_repository), owner_repository: Box::new(owner_repository),
rent_repository: Box::new(rent_repository), rent_repository: Box::new(rent_repository)
administrator_repository: Box::new(administrator_repository),
benchmark_repository: Box::new(benchmark_repository),
auth_service
})); }));
HttpServer::new(move || { HttpServer::new(move || {
App::new() App::new()
.app_data(Data::clone(&state)) .app_data(Data::clone(&state))
.service(web::scope("/api") .service(
.service( web::scope("/cars")
web::scope("/cars") .service(get_cars)
.service(get_cars) .service(get_car)
.service(get_report) .service(create_car)
.service(get_car) .service(update_car)
.service(create_car) .service(delete_car)
.service(update_car) )
.service(delete_car) .service(
) web::scope("/clients")
.service( .service(get_clients)
web::scope("/clients") .service(get_client)
.service(get_clients) .service(create_client)
.service(get_client) .service(update_client)
.service(create_client) .service(delete_client)
.service(update_client) )
.service(delete_client) .service(
) web::scope("/owners")
.service( .service(get_owners)
web::scope("/owners") .service(get_owner)
.service(get_owners) .service(create_owner)
.service(get_owner) .service(update_owner)
.service(create_owner) .service(delete_owner)
.service(update_owner) )
.service(delete_owner) .service(
) web::scope("/car_stations")
.service( .service(get_car_stations)
web::scope("/car_stations") .service(get_car_station)
.service(get_car_stations) .service(create_car_station)
.service(get_car_station) .service(update_car_station)
.service(create_car_station) .service(delete_car_station)
.service(update_car_station) )
.service(delete_car_station) .service(
) web::scope("/rents")
.service( .service(get_rents)
web::scope("/rents") .service(get_rent)
.service(get_rents) .service(create_rent)
.service(get_rent) .service(update_rent)
.service(create_rent) .service(delete_rent)
.service(update_rent) )
.service(delete_rent)
.service(end_rent)
)
.service(login)
.service(logout)
).service(benchmark)
}) })
.bind("127.0.0.1:8080")? .bind("127.0.0.1:8080")?
.run() .run()

12
backend/src/models/administrator.rs
View File

@ -1,12 +0,0 @@
use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Administrator {
pub id: i32,
pub username: String,
pub password: String,
pub name: String,
pub surname: String,
pub middlename: String,
pub car_station_id: i32
}

18
backend/src/models/car.rs
View File

@ -1,4 +1,3 @@
use rust_decimal::Decimal;
use serde::{Serialize, Deserialize}; use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
@ -6,7 +5,7 @@ pub struct Car {
pub id: i32, pub id: i32,
pub brand: String, pub brand: String,
pub model: String, pub model: String,
pub price: Decimal, pub price: f64,
pub owner_id: i32, pub owner_id: i32,
pub car_station_id: i32 pub car_station_id: i32
} }
@ -15,16 +14,7 @@ pub struct Car {
pub struct BindingCar { pub struct BindingCar {
pub brand: String, pub brand: String,
pub model: String, pub model: String,
pub price: Decimal, pub price: f64,
pub owner_id: i32, pub owner_id: u32,
pub car_station_id: i32 pub car_station_id: u32
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Report {
pub car_id: i32,
pub brand: String,
pub model: String,
pub times: i64,
pub income: Decimal
} }

1
backend/src/models/mod.rs
View File

@ -2,4 +2,3 @@ pub mod client;
pub mod car_station; pub mod car_station;
pub mod car; pub mod car;
pub mod rent; pub mod rent;
pub mod administrator;

8
backend/src/models/rent.rs
View File

@ -3,7 +3,7 @@ use serde::{Serialize, Deserialize};
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Rent { pub struct Rent {
pub id: i32, pub id: i32,
pub start_time: chrono::NaiveDateTime, pub start_time: chrono::NaiveTime,
pub time_amount: Option<i32>, pub time_amount: Option<i32>,
pub client_id: i32, pub client_id: i32,
pub car_id: i32 pub car_id: i32
@ -11,7 +11,7 @@ pub struct Rent {
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BindingRent { pub struct BindingRent {
pub time_amount: Option<i32>, pub time_amount: Option<u32>,
pub client_id: i32, pub client_id: u32,
pub car_id: i32 pub car_id: u32
} }

34
backend/src/services/auth.rs
View File

@ -1,34 +0,0 @@
use crate::{storages::traits::AdministratorRepository, models::administrator::Administrator};
use nanoid::nanoid;
use sha2::Sha256;
use std::cell::RefCell;
pub struct AuthService {
authed: RefCell<Vec::<(String, i32)>>
}
impl AuthService {
pub fn new() -> Self {
AuthService { authed: RefCell::new(Vec::new()) }
}
pub async fn login(&self, storage: &dyn AdministratorRepository, username: &str, password: &str) -> Result<(String, i32, i32), String> {
let administrator = storage.find_by_username(&username).await?;
if pbkdf2::pbkdf2_hmac_array::<Sha256, 32>(password.as_bytes(), dotenv_codegen::dotenv!("SALT").as_bytes(), 4096).iter().map(|x| format!("{:x}", x)).collect::<String>() != administrator.password {
Err("Invalid password or login!".to_owned())
} else {
let token = nanoid!(32);
self.authed.borrow_mut().push((token.clone(), administrator.id));
Ok((token, administrator.id, administrator.car_station_id))
}
}
pub fn logout(&self, token: &str) {
self.authed.borrow_mut().retain(|x| x.0 != token);
}
pub async fn administrator_by_token(&self, storage: &dyn AdministratorRepository, token: &str) -> Result<Administrator, String> {
let id = self.authed.borrow().iter().find(|&x| x.0.starts_with(token)).ok_or("Invalid token")?.1;
storage.read(id).await
}
}

1
backend/src/services/mod.rs
View File

@ -1 +0,0 @@
pub mod auth;

52
backend/src/storages/postgres/administrator.rs
View File

@ -1,52 +0,0 @@
use tokio_postgres::Client as PgClient;
use std::sync::Arc;
use crate::models::administrator::Administrator;
use crate::storages::traits::AdministratorRepository;
use async_trait::async_trait;
pub struct PostgresAdministratorRepository {
pub connection: Arc<PgClient>
}
#[async_trait]
impl AdministratorRepository for PostgresAdministratorRepository {
async fn read(&self, id: i32) -> Result<Administrator, String> {
let result = self.connection.query(
"SELECT * FROM administrator WHERE id = $1", &[&id]
).await;
if let Ok(rows) = result {
let row = rows.get(0).ok_or("Administrator not found".to_owned())?;
Ok(Administrator {
id: row.get("id"),
username: row.get("username"),
password: row.get("password"),
name: row.get("name"),
surname: row.get("surname"),
middlename: row.get("middlename"),
car_station_id: row.get("car_station_id")
})
} else {
Err(result.unwrap_err().to_string())
}
}
async fn find_by_username(&self, username: &str) -> Result<Administrator, String> {
let result = self.connection.query("SELECT * FROM administrator WHERE username LIKE $1", &[&username]).await;
if let Ok(rows) = result {
let row = rows.get(0).ok_or("Administrator not found".to_owned())?;
Ok(Administrator {
id: row.get("id"),
username: row.get("username"),
password: row.get("password"),
name: row.get("name"),
surname: row.get("surname"),
middlename: row.get("middlename"),
car_station_id: row.get("car_station_id")
})
} else {
Err(result.unwrap_err().to_string())
}
}
}

49
backend/src/storages/postgres/benchmark.rs
View File

@ -1,49 +0,0 @@
use tokio_postgres::Client as PgClient;
use std::sync::Arc;
use crate::storages::traits::BenchmarkRepository;
use async_trait::async_trait;
pub struct PostgresBenchmarkRepository {
pub connection: Arc<PgClient>
}
#[async_trait]
impl BenchmarkRepository for PostgresBenchmarkRepository {
async fn benchmark(&self) -> Result<i64, String> {
self.connection.execute("DELETE FROM Rent", &[]).await.unwrap();
self.connection.execute("DELETE FROM Car", &[]).await.unwrap();
self.connection.execute("DELETE FROM Owner", &[]).await.unwrap();
self.connection.execute("DELETE FROM Client", &[]).await.unwrap();
let start_time = chrono::Utc::now().naive_local();
for n in 1..201 {
let str = format!("INSERT INTO Owner(name, surname, middlename, phone) VALUES ('Иван{0}', 'Иванов{0}', 'Иванович{0}', {0}) RETURNING id", n);
let owner_id: i32 = self.connection.query(
&str,
&[]
).await.unwrap().get(0).unwrap().get(0);
let client_id: i32 = self.connection.query(
&str.replace("Owner", "Client").replace("Иван", "Петр"),
&[]
).await.unwrap().get(0).unwrap().get(0);
let str = format!("INSERT INTO Car(Brand, Model, Price, owner_id, car_station_id) VALUES ('Лада{0}', 'Гранта{0}', {0}.00, {1}, 2) RETURNING id", n, owner_id);
let car_id: i32 = self.connection.query(
&str,
&[]
).await.unwrap().get(0).unwrap().get(0);
let str = format!("INSERT INTO Rent(car_id, client_id, start_time, time_amount) VALUES ({1}, {2}, now()::timestamp, {0}) RETURNING id", n, car_id, client_id);
let rent_id: i32 = self.connection.query(
&str,
&[]
).await.unwrap().get(0).unwrap().get(0);
}
let elapsed = chrono::Utc::now().naive_local() - start_time;
Ok(elapsed.num_microseconds().unwrap())
}
}

49
backend/src/storages/postgres/car.rs
View File

@ -1,6 +1,6 @@
use tokio_postgres::Client as PgClient; use tokio_postgres::Client as PgClient;
use std::sync::Arc; use std::sync::Arc;
use crate::models::car::{BindingCar, Car, Report}; use crate::models::car::{BindingCar, Car};
use crate::storages::traits::CarRepository; use crate::storages::traits::CarRepository;
use async_trait::async_trait; use async_trait::async_trait;
@ -28,11 +28,11 @@ impl CarRepository for PostgresCarRepository {
car_station_id: row.get("car_station_id") car_station_id: row.get("car_station_id")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during creation of Car".to_owned())
} }
} }
async fn read(&self, id: i32) -> Result<Car, String> { async fn read(&self, id: u32) -> Result<Car, String> {
let result = self.connection.query( let result = self.connection.query(
"SELECT * FROM Car WHERE id = $1", &[&id] "SELECT * FROM Car WHERE id = $1", &[&id]
).await; ).await;
@ -48,7 +48,7 @@ impl CarRepository for PostgresCarRepository {
car_station_id: row.get("car_station_id") car_station_id: row.get("car_station_id")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading of Car".to_owned())
} }
} }
@ -69,11 +69,11 @@ impl CarRepository for PostgresCarRepository {
}).collect() }).collect()
) )
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading CarStations".to_owned())
} }
} }
async fn update(&self, id: i32, car: BindingCar) -> Result<Car, String> { async fn update(&self, id: u32, car: BindingCar) -> Result<Car, String> {
let result = self.connection.query( let result = self.connection.query(
"UPDATE Car SET brand = $1, model = $2, price = $3, owner_id = $4, car_station_id = $5 WHERE id = $6 RETURNING *", "UPDATE Car SET brand = $1, model = $2, price = $3, owner_id = $4, car_station_id = $5 WHERE id = $6 RETURNING *",
&[&car.brand, &car.model, &car.price, &car.owner_id, &car.car_station_id, &id] &[&car.brand, &car.model, &car.price, &car.owner_id, &car.car_station_id, &id]
@ -90,11 +90,11 @@ impl CarRepository for PostgresCarRepository {
car_station_id: row.get("car_station_id") car_station_id: row.get("car_station_id")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during updating of Car".to_owned())
} }
} }
async fn delete(&self, id: i32) -> Result<(), String> { async fn delete(&self, id: u32) -> Result<(), String> {
let result = self.connection.execute( let result = self.connection.execute(
"DELETE FROM Car WHERE id = $1", "DELETE FROM Car WHERE id = $1",
&[&id] &[&id]
@ -107,38 +107,7 @@ impl CarRepository for PostgresCarRepository {
Ok(()) Ok(())
} }
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during deleting of Car".to_owned())
}
}
async fn get_report(&self) -> Result<Vec<Report>, String> {
let result = self.connection.query(
"SELECT
c.id AS \"car_id\",
c.brand AS \"brand\",
c.model AS \"model\",
COUNT(r.id) AS \"times\",
ROUND(SUM(c.price * r.time_amount), 2) AS \"income\"
FROM car c
JOIN rent r ON c.id = r.car_id
WHERE date_trunc('month', r.start_time) = date_trunc('month', CURRENT_DATE)
GROUP BY c.id;", &[]
).await;
if let Ok(rows) = result {
Ok(
rows.into_iter()
.map(|row| Report {
car_id: row.get("car_id"),
brand: row.get("brand"),
model: row.get("model"),
times: row.get("times"),
income: row.get("income")
})
.collect()
)
} else {
Err(result.unwrap_err().to_string())
} }
} }
} }

16
backend/src/storages/postgres/car_station.rs
View File

@ -23,11 +23,11 @@ impl CarStationRepository for PostgresCarStationRepository {
address: row.get("address") address: row.get("address")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during creation of CarStation".to_owned())
} }
} }
async fn read(&self, id: i32) -> Result<CarStation, String> { async fn read(&self, id: u32) -> Result<CarStation, String> {
let result = self.connection.query( let result = self.connection.query(
"SELECT * FROM Car_Station WHERE id = $1", &[&id] "SELECT * FROM Car_Station WHERE id = $1", &[&id]
).await; ).await;
@ -39,7 +39,7 @@ impl CarStationRepository for PostgresCarStationRepository {
address: row.get("address") address: row.get("address")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading of CarStation".to_owned())
} }
} }
@ -56,11 +56,11 @@ impl CarStationRepository for PostgresCarStationRepository {
}).collect() }).collect()
) )
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading CarStations".to_owned())
} }
} }
async fn update(&self, id: i32, car_station: BindingCarStation) -> Result<CarStation, String> { async fn update(&self, id: u32, car_station: BindingCarStation) -> Result<CarStation, String> {
let result = self.connection.query( let result = self.connection.query(
"UPDATE Car_Station SET address = $1 WHERE id = $2 RETURNING *", "UPDATE Car_Station SET address = $1 WHERE id = $2 RETURNING *",
&[&car_station.address, &id] &[&car_station.address, &id]
@ -73,11 +73,11 @@ impl CarStationRepository for PostgresCarStationRepository {
address: row.get("address") address: row.get("address")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during updating of CarStation".to_owned())
} }
} }
async fn delete(&self, id: i32) -> Result<(), String> { async fn delete(&self, id: u32) -> Result<(), String> {
let result = self.connection.execute( let result = self.connection.execute(
"DELETE FROM Car_Station WHERE id = $1", "DELETE FROM Car_Station WHERE id = $1",
&[&id] &[&id]
@ -90,7 +90,7 @@ impl CarStationRepository for PostgresCarStationRepository {
Ok(()) Ok(())
} }
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during deleting of CarStation".to_owned())
} }
} }
} }

16
backend/src/storages/postgres/client.rs
View File

@ -27,11 +27,11 @@ impl ClientRepository for PostgresClientRepository {
phone: row.get("phone") phone: row.get("phone")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during creation of Client".to_owned())
} }
} }
async fn read(&self, id: i32) -> Result<Client, String> { async fn read(&self, id: u32) -> Result<Client, String> {
let result= self.connection.query( let result= self.connection.query(
"SELECT * FROM Client WHERE id = $1", &[&id] "SELECT * FROM Client WHERE id = $1", &[&id]
).await; ).await;
@ -47,7 +47,7 @@ impl ClientRepository for PostgresClientRepository {
phone: row.get("phone") phone: row.get("phone")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading of Client".to_owned())
} }
} }
@ -67,11 +67,11 @@ impl ClientRepository for PostgresClientRepository {
}).collect() }).collect()
) )
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading Clients".to_owned())
} }
} }
async fn update(&self, id: i32, client: BindingClient) -> Result<Client, String> { async fn update(&self, id: u32, client: BindingClient) -> Result<Client, String> {
let result = self.connection.query( let result = self.connection.query(
"UPDATE Client SET name = $1, surname = $2, middlename = $3, phone = $4 \ "UPDATE Client SET name = $1, surname = $2, middlename = $3, phone = $4 \
WHERE id = $5 RETURNING *", WHERE id = $5 RETURNING *",
@ -88,11 +88,11 @@ impl ClientRepository for PostgresClientRepository {
phone: row.get("phone") phone: row.get("phone")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during updating of Client".to_owned())
} }
} }
async fn delete(&self, id: i32) -> Result<(), String> { async fn delete(&self, id: u32) -> Result<(), String> {
let result = self.connection.execute( let result = self.connection.execute(
"DELETE FROM Client WHERE id = $1", "DELETE FROM Client WHERE id = $1",
&[&id] &[&id]
@ -105,7 +105,7 @@ impl ClientRepository for PostgresClientRepository {
Ok(()) Ok(())
} }
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during deleting of Client".to_owned())
} }
} }
} }

2
backend/src/storages/postgres/mod.rs
View File

@ -3,5 +3,3 @@ pub mod car_station;
pub mod car; pub mod car;
pub mod rent; pub mod rent;
pub mod owner; pub mod owner;
pub mod administrator;
pub mod benchmark;

16
backend/src/storages/postgres/owner.rs
View File

@ -27,11 +27,11 @@ impl OwnerRepository for PostgresOwnerRepository {
phone: row.get("phone") phone: row.get("phone")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during creation of Owner".to_owned())
} }
} }
async fn read(&self, id: i32) -> Result<Client, String> { async fn read(&self, id: u32) -> Result<Client, String> {
let result= self.connection.query( let result= self.connection.query(
"SELECT * FROM Owner WHERE id = $1", &[&id] "SELECT * FROM Owner WHERE id = $1", &[&id]
).await; ).await;
@ -47,7 +47,7 @@ impl OwnerRepository for PostgresOwnerRepository {
phone: row.get("phone") phone: row.get("phone")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading of Owner".to_owned())
} }
} }
@ -67,11 +67,11 @@ impl OwnerRepository for PostgresOwnerRepository {
}).collect() }).collect()
) )
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading Owner".to_owned())
} }
} }
async fn update(&self, id: i32, client: BindingClient) -> Result<Client, String> { async fn update(&self, id: u32, client: BindingClient) -> Result<Client, String> {
let result = self.connection.query( let result = self.connection.query(
"UPDATE Owner SET name = $1, surname = $2, middlename = $3, phone = $4 \ "UPDATE Owner SET name = $1, surname = $2, middlename = $3, phone = $4 \
WHERE id = $5 RETURNING *", WHERE id = $5 RETURNING *",
@ -88,11 +88,11 @@ impl OwnerRepository for PostgresOwnerRepository {
phone: row.get("phone") phone: row.get("phone")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during updating of Owner".to_owned())
} }
} }
async fn delete(&self, id: i32) -> Result<(), String> { async fn delete(&self, id: u32) -> Result<(), String> {
let result = self.connection.execute( let result = self.connection.execute(
"DELETE FROM Owner WHERE id = $1", "DELETE FROM Owner WHERE id = $1",
&[&id] &[&id]
@ -105,7 +105,7 @@ impl OwnerRepository for PostgresOwnerRepository {
Ok(()) Ok(())
} }
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during deleting of Owner".to_owned())
} }
} }
} }

35
backend/src/storages/postgres/rent.rs
View File

@ -12,7 +12,7 @@ pub struct PostgresRentRepository {
impl RentRepository for PostgresRentRepository { impl RentRepository for PostgresRentRepository {
async fn create(&self, rent: BindingRent) -> Result<Rent, String> { async fn create(&self, rent: BindingRent) -> Result<Rent, String> {
let query_result = self.connection.query( let query_result = self.connection.query(
"SELECT * FROM Rent WHERE car_id=$1 AND time_amount IS NULL", "SELECT * FROM Rent WHERE car_id=$1 AND time_amount IS NOT NULL",
&[&rent.car_id] &[&rent.car_id]
).await; ).await;
@ -21,7 +21,7 @@ impl RentRepository for PostgresRentRepository {
return Err("The car is already occupied".to_owned()); return Err("The car is already occupied".to_owned());
} }
} else { } else {
return Err(query_result.unwrap_err().to_string()); return Err("Something gone wrong during checking for existing rents".to_owned());
} }
let result = self.connection.query( let result = self.connection.query(
@ -40,11 +40,11 @@ impl RentRepository for PostgresRentRepository {
car_id: row.get("car_id") car_id: row.get("car_id")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during creation of Rent".to_owned())
} }
} }
async fn read(&self, id: i32) -> Result<Rent, String> { async fn read(&self, id: u32) -> Result<Rent, String> {
let result = self.connection.query( let result = self.connection.query(
"SELECT * FROM Rent WHERE id = $1", &[&id] "SELECT * FROM Rent WHERE id = $1", &[&id]
).await; ).await;
@ -59,7 +59,7 @@ impl RentRepository for PostgresRentRepository {
car_id: row.get("car_id") car_id: row.get("car_id")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading of Rent".to_owned())
} }
} }
@ -79,11 +79,11 @@ impl RentRepository for PostgresRentRepository {
}).collect() }).collect()
) )
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during reading CarStations".to_owned())
} }
} }
async fn update(&self, id: i32, rent: BindingRent) -> Result<Rent, String> { async fn update(&self, id: u32, rent: BindingRent) -> Result<Rent, String> {
let result = self.connection.query( let result = self.connection.query(
"UPDATE Rent SET time_amount = $2, client_id = $3, car_id = $4 WHERE id = $5 RETURNING *", "UPDATE Rent SET time_amount = $2, client_id = $3, car_id = $4 WHERE id = $5 RETURNING *",
&[&rent.time_amount, &rent.client_id, &rent.car_id, &id] &[&rent.time_amount, &rent.client_id, &rent.car_id, &id]
@ -99,11 +99,11 @@ impl RentRepository for PostgresRentRepository {
car_id: row.get("car_id") car_id: row.get("car_id")
}) })
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during updating of Rent".to_owned())
} }
} }
async fn delete(&self, id: i32) -> Result<(), String> { async fn delete(&self, id: u32) -> Result<(), String> {
let result = self.connection.execute( let result = self.connection.execute(
"DELETE FROM Rent WHERE id = $1", &[&id] "DELETE FROM Rent WHERE id = $1", &[&id]
).await; ).await;
@ -111,22 +111,7 @@ impl RentRepository for PostgresRentRepository {
if let Ok(_) = result { if let Ok(_) = result {
Ok(()) Ok(())
} else { } else {
Err(result.unwrap_err().to_string()) Err("Something gone wrong during deletion of Rent".to_owned())
}
}
async fn end_rent(&self, id: i32) -> Result<(), String> {
let current_rent = self.read(id).await?;
if current_rent.time_amount.is_some() {
return Err("Rent is already ended".to_owned());
}
let time_amount = (self.connection.query("SELECT now()::timestamp", &[]).await.unwrap().get(0).unwrap().get::<usize, chrono::NaiveDateTime>(0) - current_rent.start_time).num_minutes() as i32;
match self.connection.execute("UPDATE Rent SET time_amount = $2 WHERE id = $1", &[&id, &time_amount]).await {
Ok(_) => Ok(()),
Err(err) => Err(err.to_string())
} }
} }
} }

44
backend/src/storages/traits.rs
View File

@ -1,4 +1,3 @@
use crate::models::administrator::Administrator;
use crate::models::client::*; use crate::models::client::*;
use crate::models::car_station::*; use crate::models::car_station::*;
use crate::models::car::*; use crate::models::car::*;
@ -8,57 +7,44 @@ use async_trait::async_trait;
#[async_trait] #[async_trait]
pub trait ClientRepository { pub trait ClientRepository {
async fn create(&self, client: BindingClient) -> Result<Client, String>; async fn create(&self, client: BindingClient) -> Result<Client, String>;
async fn read(&self, id: i32) -> Result<Client, String>; async fn read(&self, id: u32) -> Result<Client, String>;
async fn read_all(&self) -> Result<Vec<Client>, String>; async fn read_all(&self) -> Result<Vec<Client>, String>;
async fn update(&self, id: i32, client: BindingClient) -> Result<Client, String>; async fn update(&self, id: u32, client: BindingClient) -> Result<Client, String>;
async fn delete(&self, id: i32) -> Result<(), String>; async fn delete(&self, id: u32) -> Result<(), String>;
} }
#[async_trait] #[async_trait]
pub trait CarRepository { pub trait CarRepository {
async fn create(&self, car: BindingCar) -> Result<Car, String>; async fn create(&self, car: BindingCar) -> Result<Car, String>;
async fn read(&self, id: i32) -> Result<Car, String>; async fn read(&self, id: u32) -> Result<Car, String>;
async fn read_all(&self) -> Result<Vec<Car>, String>; async fn read_all(&self) -> Result<Vec<Car>, String>;
async fn update(&self, id: i32, car: BindingCar) -> Result<Car, String>; async fn update(&self, id: u32, car: BindingCar) -> Result<Car, String>;
async fn delete(&self, id: i32) -> Result<(), String>; async fn delete(&self, id: u32) -> Result<(), String>;
async fn get_report(&self) -> Result<Vec<Report>, String>;
} }
#[async_trait] #[async_trait]
pub trait CarStationRepository { pub trait CarStationRepository {
async fn create(&self, car_station: BindingCarStation) -> Result<CarStation, String>; async fn create(&self, car_station: BindingCarStation) -> Result<CarStation, String>;
async fn read(&self, id: i32) -> Result<CarStation, String>; async fn read(&self, id: u32) -> Result<CarStation, String>;
async fn read_all(&self) -> Result<Vec<CarStation>, String>; async fn read_all(&self) -> Result<Vec<CarStation>, String>;
async fn update(&self, id: i32, car_station: BindingCarStation) -> Result<CarStation, String>; async fn update(&self, id: u32, car_station: BindingCarStation) -> Result<CarStation, String>;
async fn delete(&self, id: i32) -> Result<(), String>; async fn delete(&self, id: u32) -> Result<(), String>;
} }
#[async_trait] #[async_trait]
pub trait RentRepository { pub trait RentRepository {
async fn create(&self, rent: BindingRent) -> Result<Rent, String>; async fn create(&self, rent: BindingRent) -> Result<Rent, String>;
async fn read(&self, id: i32) -> Result<Rent, String>; async fn read(&self, id: u32) -> Result<Rent, String>;
async fn read_all(&self) -> Result<Vec<Rent>, String>; async fn read_all(&self) -> Result<Vec<Rent>, String>;
async fn update(&self, id: i32, rent: BindingRent) -> Result<Rent, String>; async fn update(&self, id: u32, rent: BindingRent) -> Result<Rent, String>;
async fn delete(&self, id: i32) -> Result<(), String>; async fn delete(&self, id: u32) -> Result<(), String>;
async fn end_rent(&self, id: i32) -> Result<(), String>;
} }
#[async_trait] #[async_trait]
pub trait OwnerRepository { pub trait OwnerRepository {
async fn create(&self, client: BindingClient) -> Result<Client, String>; async fn create(&self, client: BindingClient) -> Result<Client, String>;
async fn read(&self, id: i32) -> Result<Client, String>; async fn read(&self, id: u32) -> Result<Client, String>;
async fn read_all(&self) -> Result<Vec<Client>, String>; async fn read_all(&self) -> Result<Vec<Client>, String>;
async fn update(&self, id: i32, client: BindingClient) -> Result<Client, String>; async fn update(&self, id: u32, client: BindingClient) -> Result<Client, String>;
async fn delete(&self, id: i32) -> Result<(), String>; async fn delete(&self, id: u32) -> Result<(), String>;
}
#[async_trait]
pub trait AdministratorRepository {
async fn read(&self, id: i32) -> Result<Administrator, String>;
async fn find_by_username(&self, username: &str) -> Result<Administrator, String>;
}
#[async_trait]
pub trait BenchmarkRepository {
async fn benchmark(&self) -> Result<i64, String>;
} }