Ruderverein-Donau-Linz/rowt
1
1
Fork 1
Code Issues 49 Pull Requests Actions Packages Projects Wiki Activity

add first draft of logbook

Browse Source
This commit is contained in:
philipp
2023-07-23 12:17:57 +02:00
parent f09454fb38
commit 1d4c5f356d
10 changed files with 507 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
src/model/logbook.rs Normal file
View File

@ -0,0 +1,231 @@
use chrono::NaiveDateTime;
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, SqlitePool};
#[derive(FromRow, Debug, Serialize, Deserialize)]
pub struct Logbook {
pub id: i64,
pub boat_id: i64,
pub shipmaster: i64,
#[serde(default = "bool::default")]
pub shipmaster_only_steering: bool,
pub departure: String, //TODO: Switch to chrono::nativedatetime
pub arrival: Option<String>, //TODO: Switch to chrono::nativedatetime
pub destination: Option<String>,
pub distance_in_km: Option<i64>,
pub comments: Option<String>,
pub logtype: Option<i64>,
}
#[derive(Serialize, FromRow)]
pub struct LogbookWithBoatAndUsers {
pub id: i64,
pub boat_id: i64,
pub shipmaster: i64,
#[serde(default = "bool::default")]
pub shipmaster_only_steering: bool,
pub departure: String, //TODO: Switch to chrono::nativedatetime
pub arrival: Option<String>, //TODO: Switch to chrono::nativedatetime
pub destination: Option<String>,
pub distance_in_km: Option<i64>,
pub comments: Option<String>,
pub logtype: Option<i64>,
pub boat: String,
pub shipmaster_name: String,
}
impl Logbook {
//pub async fn find_by_id(db: &SqlitePool, id: i32) -> Option<Self> {
// sqlx::query_as!(
// Self,
// "
//SELECT id, name, amount_seats, location_id, owner, year_built, boatbuilder, default_shipmaster_only_steering, skull, external
//FROM boat
//WHERE id like ?
// ",
// id
// )
// .fetch_one(db)
// .await
// .ok()
//}
//
// pub async fn find_by_name(db: &SqlitePool, name: &str) -> Option<Self> {
// sqlx::query_as!(
// User,
// "
//SELECT id, name, pw, is_cox, is_admin, is_guest, deleted, last_access
//FROM user
//WHERE name like ?
// ",
// name
// )
// .fetch_one(db)
// .await
// .ok()
// }
//
pub async fn on_water(db: &SqlitePool) -> Vec<LogbookWithBoatAndUsers> {
sqlx::query_as!(
LogbookWithBoatAndUsers,
"
SELECT logbook.id, boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype, boat.name as boat, user.name as shipmaster_name
FROM logbook
INNER JOIN boat ON logbook.boat_id = boat.id
INNER JOIN user ON shipmaster = user.id
WHERE arrival is null
ORDER BY departure DESC
"
)
.fetch_all(db)
.await
.unwrap() //TODO: fixme
}
pub async fn completed(db: &SqlitePool) -> Vec<LogbookWithBoatAndUsers> {
sqlx::query_as!(
LogbookWithBoatAndUsers,
"
SELECT logbook.id, boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype, boat.name as boat, user.name as shipmaster_name
FROM logbook
INNER JOIN boat ON logbook.boat_id = boat.id
INNER JOIN user ON shipmaster = user.id
WHERE arrival is not null
ORDER BY arrival DESC
"
)
.fetch_all(db)
.await
.unwrap() //TODO: fixme
}
pub async fn create(
db: &SqlitePool,
boat_id: i64,
shipmaster: i64,
shipmaster_only_steering: bool,
departure: NaiveDateTime,
arrival: Option<NaiveDateTime>,
destination: Option<String>,
distance_in_km: Option<i64>,
comments: Option<String>,
logtype: Option<i64>,
) -> bool {
sqlx::query!(
"INSERT INTO logbook(boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype) VALUES (?,?,?,?,?,?,?,?,?)",
boat_id, shipmaster, shipmaster_only_steering, departure, arrival, destination, distance_in_km, comments, logtype
)
.execute(db)
.await.is_ok()
}
//
// pub async fn update(
// &self,
// db: &SqlitePool,
// name: &str,
// amount_seats: i64,
// year_built: Option<i64>,
// boatbuilder: Option<&str>,
// default_shipmaster_only_steering: bool,
// skull: bool,
// external: bool,
// location_id: Option<i64>,
// owner: Option<i64>,
// ) -> bool {
// sqlx::query!(
// "UPDATE boat SET name=?, amount_seats=?, year_built=?, boatbuilder=?, default_shipmaster_only_steering=?, skull=?, external=?, location_id=?, owner=? WHERE id=?",
// name,
// amount_seats,
// year_built,
// boatbuilder,
// default_shipmaster_only_steering,
// skull,
// external,
// location_id,
// owner,
// self.id
// )
// .execute(db)
// .await
// .is_ok()
// }
//
// pub async fn delete(&self, db: &SqlitePool) {
// sqlx::query!("DELETE FROM boat WHERE id=?", self.id)
// .execute(db)
// .await
// .unwrap(); //Okay, because we can only create a User of a valid id
// }
}
//
//#[cfg(test)]
//mod test {
// use crate::{model::boat::Boat, testdb};
//
// use sqlx::SqlitePool;
//
// #[sqlx::test]
// fn test_find_correct_id() {
// let pool = testdb!();
// let boat = Boat::find_by_id(&pool, 1).await.unwrap();
// assert_eq!(boat.id, 1);
// }
//
// #[sqlx::test]
// fn test_find_wrong_id() {
// let pool = testdb!();
// let boat = Boat::find_by_id(&pool, 1337).await;
// assert!(boat.is_none());
// }
//
// #[sqlx::test]
// fn test_all() {
// let pool = testdb!();
// let res = Boat::all(&pool).await;
// assert!(res.len() > 3);
// }
//
// #[sqlx::test]
// fn test_succ_create() {
// let pool = testdb!();
//
// assert_eq!(
// Boat::create(
// &pool,
// "new-boat-name".into(),
// 42,
// None,
// "Best Boatbuilder".into(),
// true,
// true,
// false,
// Some(1),
// None
// )
// .await,
// true
// );
// }
//
// #[sqlx::test]
// fn test_duplicate_name_create() {
// let pool = testdb!();
//
// assert_eq!(
// Boat::create(
// &pool,
// "Haichenbach".into(),
// 42,
// None,
// "Best Boatbuilder".into(),
// true,
// true,
// false,
// Some(1),
// None
// )
// .await,
// false
// );
// }
//}

52
src/model/logtype.rs Normal file
View File

@ -0,0 +1,52 @@
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, SqlitePool};
#[derive(FromRow, Debug, Serialize, Deserialize, Clone)]
pub struct LogType{
pub id: i64,
name: String,
}
impl LogType{
pub async fn find_by_id(db: &SqlitePool, id: i64) -> Option<Self> {
sqlx::query_as!(
Self,
"
SELECT id, name
FROM logbook_type
WHERE id like ?
",
id
)
.fetch_one(db)
.await
.ok()
}
pub async fn all(db: &SqlitePool) -> Vec<Self> {
sqlx::query_as!(
Self,
"
SELECT id, name
FROM logbook_type
"
)
.fetch_all(db)
.await
.unwrap() //TODO: fixme
}
}
#[cfg(test)]
mod test {
use crate::testdb;
use sqlx::SqlitePool;
#[sqlx::test]
fn test_find_true() {
let pool = testdb!();
}
//TODO: write tests
}

2
src/model/mod.rs
View File

@ -10,6 +10,8 @@ use self::{
pub mod boat;
pub mod location;
pub mod log;
pub mod logbook;
pub mod logtype;
pub mod planned_event;
pub mod trip;
pub mod tripdetails;

22
src/model/user.rs
View File

@ -85,6 +85,21 @@ ORDER BY last_access DESC
.unwrap() //TODO: fixme
}
pub async fn cox(db: &SqlitePool) -> Vec<Self> {
sqlx::query_as!(
User,
"
SELECT id, name, pw, is_cox, is_admin, is_guest, deleted, last_access
FROM user
WHERE deleted = 0 AND is_cox=true
ORDER BY last_access DESC
"
)
.fetch_all(db)
.await
.unwrap() //TODO: fixme
}
pub async fn create(db: &SqlitePool, name: &str, is_guest: bool) -> bool {
sqlx::query!(
"INSERT INTO USER(name, is_guest) VALUES (?,?)",
@ -365,6 +380,13 @@ mod test {
assert!(res.len() > 3);
}
#[sqlx::test]
fn test_cox() {
let pool = testdb!();
let res = User::cox(&pool).await;
assert_eq!(res.len(), 2);
}
#[sqlx::test]
fn test_succ_create() {
let pool = testdb!();

94
src/tera/log.rs Normal file
View File

@ -0,0 +1,94 @@
use chrono::NaiveDateTime;
use rocket::{
form::Form,
get, post,
request::FlashMessage,
response::{Flash, Redirect},
routes, FromForm, Route, State,
};
use rocket_dyn_templates::Template;
use sqlx::SqlitePool;
use tera::Context;
use crate::model::{
boat::Boat,
logbook::Logbook,
logtype::LogType,
user::{AdminUser, User},
};
#[get("/")]
async fn index(
db: &State<SqlitePool>,
flash: Option<FlashMessage<'_>>,
adminuser: AdminUser,
) -> Template {
let boats = Boat::all(db).await;
let users = User::cox(db).await;
let logtypes = LogType::all(db).await;
let on_water = Logbook::on_water(db).await;
let completed = Logbook::completed(db).await;
let mut context = Context::new();
if let Some(msg) = flash {
context.insert("flash", &msg.into_inner());
}
context.insert("boats", &boats);
context.insert("users", &users);
context.insert("logtypes", &logtypes);
context.insert("loggedin_user", &adminuser.user);
context.insert("on_water", &on_water);
context.insert("completed", &completed);
Template::render("log", context.into_json())
}
#[derive(FromForm)]
struct LogAddForm {
boat_id: i64,
shipmaster: i64,
shipmaster_only_steering: bool,
departure: String,
arrival: Option<String>,
destination: Option<String>,
distance_in_km: Option<i64>,
comments: Option<String>,
logtype: Option<i64>,
}
#[post("/", data = "<data>")]
async fn create(
db: &State<SqlitePool>,
data: Form<LogAddForm>,
_adminuser: AdminUser,
) -> Flash<Redirect> {
if Logbook::create(
db,
data.boat_id,
data.shipmaster,
data.shipmaster_only_steering,
NaiveDateTime::parse_from_str(&data.departure, "%Y-%m-%dT%H:%M").unwrap(), //TODO: fix
data.arrival
.clone()
.map(|a| NaiveDateTime::parse_from_str(&a, "%Y-%m-%dT%H:%M").unwrap()), //TODO: fix
data.destination.clone(), //TODO: fix
data.distance_in_km,
data.comments.clone(), //TODO: fix
data.logtype,
)
.await
{
Flash::success(Redirect::to("/log"), "Ausfahrt erfolgreich hinzugefügt")
} else {
Flash::error(Redirect::to("/log"), format!("Fehler beim hinzufügen!"))
}
}
pub fn routes() -> Vec<Route> {
routes![index, create]
}
#[cfg(test)]
mod test {}

2
src/tera/mod.rs
View File

@ -22,6 +22,7 @@ use crate::model::{
mod admin;
mod auth;
mod cox;
mod log;
mod misc;
#[get("/")]
@ -114,6 +115,7 @@ pub fn config(rocket: Rocket<Build>) -> Rocket<Build> {
rocket
.mount("/", routes![index, join, remove])
.mount("/auth", auth::routes())
.mount("/log", log::routes())
.mount("/cox", cox::routes())
.mount("/admin", admin::routes())
.mount("/", misc::routes())