Add stage and stage count information

fvacek · fvacek · commit 7d1bd333ccfd · 2025-07-04T11:25:04.000+02:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -23,5 +23,4 @@ image = "0.25.5"
 flate2 = "1.1.0"
 itertools = "0.14.0"
 async-broadcast = "0.7.2"
-csv = "1.3.1"
-log = "0.4.26"
+csv = "1.3.1"
diff --git a/db/ev0001.sqlite b/db/ev0001.sqlite
diff --git a/db/migrations/20250703173803_add-stage-field.sql b/db/migrations/20250703173803_add-stage-field.sql
@@ -0,0 +1,3 @@
+alter table events add column stage integer not null default 1;
+alter table events add column stage_count integer not null default 1;
+
diff --git a/db/qxdb.sqlite b/db/qxdb.sqlite
diff --git a/src/event.rs b/src/event.rs
@@ -34,6 +34,8 @@ pub type EventId = i64;
 pub struct EventRecord {
     pub id: EventId,
     pub name: String,
+    pub stage: i64,
+    pub stage_count: i64,
     pub place: String,
     pub start_time: QxDateTime,
     pub owner: String,
@@ -45,6 +47,8 @@ impl EventRecord {
         Self {
             id: 0,
             name: "".to_string(),
+            stage: 1,
+            stage_count: 1,
             place: "".to_string(),
             start_time,
             // time_zone: "Europe/Prague".to_string(),
@@ -74,26 +78,33 @@ pub async fn load_event_info_for_api_token(qx_api_token: &QxApiToken, db: &State
         .fetch_one(pool)
         .await
         .map_err(|e| {
-            warn!("Unauthorized request for api token: {}", qx_api_token.0);
+            warn!("Unauthorized request for api token: {}, error: {}", qx_api_token.0, e);
             Custom(Status::Unauthorized, e.to_string())
         })?;
     Ok(event)
 }
 pub(crate) async fn save_event(event: &EventRecord, db: &State<DbPool>) -> anyhow::Result<EventId> {
     let id = if event.id > 0 {
-        query("UPDATE events SET name=?, place=?, start_time=? WHERE id=?")
+        query("UPDATE events SET name=?, place=?, stage=?, stage_count=?, start_time=? WHERE id=?")
             .bind(&event.name)
             .bind(&event.place)
+            .bind(&event.stage)
+            .bind(&event.stage_count)
             .bind(event.start_time.0)
             // .bind(&event.time_zone)
             .bind(event.id)
             .execute(&db.0)
             .await.map_err(|e| anyhow!("{e}"))?;
         event.id
     } else {
-        let id: (i64, ) = query_as("INSERT INTO events(name, place, start_time, api_token, owner) VALUES (?, ?, ?, ?, ?) RETURNING id")
+        let id: (i64, ) = query_as(
+            "INSERT INTO events(name, place, stage, stage_count, start_time, api_token, owner)
+                 VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id"
+        )
             .bind(&event.name)
             .bind(&event.place)
+            .bind(&event.stage)
+            .bind(&event.stage_count)
             .bind(event.start_time.0)
             .bind(&event.api_token.0)
             .bind(&event.owner)
@@ -109,6 +120,8 @@ struct EventFormValues<'v> {
     id: EventId,
     name: &'v str,
     place: &'v str,
+    stage: i64,
+    stage_count: i64,
     start_time: &'v str,
     // #[field(validate = len(1..))]
     // owner: &'v str,
@@ -124,22 +137,26 @@ async fn post_event<'r>(form: Form<Contextual<'r, EventFormValues<'r>>>, session
     let vals = form.value.as_ref().ok_or(Custom(Status::BadRequest, "Form data invalid".to_string()))?;
     let start_time = QxDateTime::parse_from_iso(vals.start_time)
         .map_err(|e| Custom(Status::BadRequest, format!("Unrecognized date-time string: {}, error: {e}", vals.start_time)))?;
-    let event = if vals.id > 0 {
-        let event = load_event_info(vals.id, db).await?;
+    let event = if vals.id == 0 {
         EventRecord {
+            id: 0,
             name: vals.name.to_string(),
+            stage: vals.stage,
+            stage_count: vals.stage_count,
             place: vals.place.to_string(),
             start_time,
-            ..event
+            owner: user.email.clone(),
+            api_token: QxApiToken(vals.api_token.to_string()),
         }
     } else {
+        let event = load_event_info(vals.id, db).await?;
         EventRecord {
-            id: 0,
             name: vals.name.to_string(),
             place: vals.place.to_string(),
+            stage: vals.stage,
+            stage_count: vals.stage_count,
             start_time,
-            owner: user.email.clone(),
-            api_token: QxApiToken(vals.api_token.to_string()),
+            ..event
         }
     };
     if event.owner != user.email {
@@ -167,13 +184,6 @@ pub async fn get_user_info(session_id: &QxSessionId, state: &State<SharedQxState
     Ok(user_info)
 }
 
-// pub async fn event_owner_opt(event_id: EventId, session_id: MaybeSessionId, state: &State<SharedQxState>, gdb: &State<DbPool>) -> anyhow::Result<Option<UserInfo>> {
-//     let event = load_event(event_id, gdb).await?;
-//     let user = user_info_opt(session_id.0.as_ref(), state).await?
-//         .and_then(|user| if user.email == event.owner {Some(user)} else {None});
-//     Ok(user)
-// }
-
 pub fn is_event_owner(event: &EventRecord, user: Option<&UserInfo>) -> bool {
     if let Some(user) = user {
         user.email == event.owner
@@ -263,6 +273,8 @@ async fn get_api_event_current(api_token: QxApiToken, db: &State<DbPool>) -> Res
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct PostedEvent {
     pub name: String,
+    pub stage: i64,
+    pub stage_count: i64,
     pub place: String,
     pub start_time: DateTime<FixedOffset>,
 }
@@ -272,6 +284,8 @@ async fn post_api_event_current(api_token: QxApiToken, posted_event: Json<Posted
         return Err(string_to_custom_error("Event not found"));
     };
     event_info.name = posted_event.name.clone();
+    event_info.stage = posted_event.stage;
+    event_info.stage_count = posted_event.stage_count;
     event_info.place = posted_event.place.clone();
     event_info.start_time = posted_event.start_time.into();
     debug!("Post event info, start00: {}", event_info.start_time.to_iso_string());
@@ -465,12 +479,14 @@ pub async fn import_runs(edb: &SqlitePool) -> anyhow::Result<()> {
     Ok(())
 }
 
+pub(crate) const TEST_API_TOKEN: &str = "plelababamak";
+
 #[get("/event/create-demo")]
 async fn create_demo_event(state: &State<SharedQxState>, gdb: &State<DbPool>) -> Result<Redirect, Custom<String>> {
     let mut event_info = EventRecord::new("fanda.vacek@gmail.com");
     event_info.name = String::from("Demo event");
     event_info.place = String::from("Deep forest 42");
-    event_info.api_token = QxApiToken(String::from("plelababamak"));
+    event_info.api_token = QxApiToken(String::from(TEST_API_TOKEN));
     let event_id = save_event(&event_info, gdb).await.map_err(|e| Custom(Status::BadRequest, e.to_string()))?;
     {
         // upload demo start list
diff --git a/src/main.rs b/src/main.rs
@@ -14,7 +14,6 @@ use rocket::response::{status};
 use rocket::response::status::{Custom};
 use rocket_dyn_templates::{Template, context, handlebars};
 use rocket::serde::Serialize;
-use rocket_dyn_templates::handlebars::{Handlebars, Helper};
 use serde::{Deserialize};
 use sqlx::SqlitePool;
 use crate::auth::{UserInfo, QX_SESSION_ID};
@@ -23,6 +22,7 @@ use crate::db::{DbPool, DbPoolFairing};
 use crate::qxdatetime::{dtstr, obtime, obtimems};
 use crate::util::anyhow_to_custom_error;
 use async_broadcast::{broadcast};
+use rocket_dyn_templates::handlebars::{Handlebars, Helper};
 use sqlx::sqlite::{SqliteArgumentValue};
 
 #[cfg(test)]
@@ -215,6 +215,22 @@ fn rocket() -> _ {
                                            }
                                            Ok(())
                                        }));
+            handlebars.register_helper("gt",
+                                       Box::new(|h: &Helper, _r: &Handlebars, _: &handlebars::Context, _rc: &mut handlebars::RenderContext, out: &mut dyn handlebars::Output| -> handlebars::HelperResult {
+                                           let left = h.param(0).and_then(|v| v.value().as_i64()).unwrap_or(0);
+                                           let right = h.param(1).and_then(|v| v.value().as_i64()).unwrap_or(0);
+
+                                           if h.inverse().is_some() {
+                                               if left <= right {
+                                                   out.write("1")?;
+                                               }
+                                           } else {
+                                               if left > right {
+                                                   out.write("1")?;
+                                               }
+                                           }
+                                           Ok(())
+                                       }));
         }))
         .attach(DbPoolFairing())
         .mount("/", FileServer::from("./static"))
diff --git a/src/tests.rs b/src/tests.rs
@@ -1,4 +1,4 @@
-use crate::event::START_LIST_IOFXML3_FILE;
+use crate::event::{START_LIST_IOFXML3_FILE, TEST_API_TOKEN};
 use std::fs::OpenOptions;
 use std::io::{Read};
 use rocket::local::blocking::Client;
@@ -10,7 +10,6 @@ use crate::{util};
 use crate::changes::DataId;
 use crate::runs::RunsRecord;
 
-const API_TOKEN: &str = "plelababamak";
 const EVENT_ID: EventId = 1;
 
 fn create_test_server() -> Client {
@@ -27,7 +26,7 @@ fn update_event_data() {
     let client = create_test_server();
     
     let resp = client.get("/api/event/current")
-        .header(Header::new("qx-api-token", API_TOKEN))
+        .header(Header::new("qx-api-token", TEST_API_TOKEN))
         .dispatch();
     assert_eq!(resp.status(), Status::Ok);
     assert_eq!(resp.content_type(), Some(ContentType::JSON));
@@ -37,24 +36,28 @@ fn update_event_data() {
     let dt = QxDateTime::now().trimmed_to_sec();
     let post_event = PostedEvent {
         name: "Foo".to_string(),
+        stage: 2,
+        stage_count: 3,
         place: "Bar".to_string(),
         start_time: dt.0,
     };
     let resp = client.post("/api/event/current")
-        .header(Header::new("qx-api-token", API_TOKEN))
+        .header(Header::new("qx-api-token", TEST_API_TOKEN))
         .json(&post_event)
         .dispatch();
     assert_eq!(resp.status(), Status::Ok);
 
     let resp = client.get("/api/event/current")
-        .header(Header::new("qx-api-token", API_TOKEN))
+        .header(Header::new("qx-api-token", TEST_API_TOKEN))
         .dispatch();
     assert_eq!(resp.status(), Status::Ok);
     assert_eq!(resp.content_type(), Some(ContentType::JSON));
     let event = resp.into_json::<EventRecord>().unwrap();
     assert_eq!(event.name, post_event.name);
     assert_eq!(event.place, post_event.place);
     assert_eq!(event.start_time.0, post_event.start_time);
+    assert_eq!(event.stage, post_event.stage);
+    assert_eq!(event.stage_count, post_event.stage_count);
 }
 
 #[test]
@@ -66,7 +69,7 @@ fn upload_file() {
     let data = b"foo-bar-baz";
     let compressed_data = util::test::zip_data(data).unwrap();
     let resp = client.post(format!("/api/event/current/file?name={file_name}"))
-        .header(Header::new("qx-api-token", API_TOKEN))
+        .header(Header::new("qx-api-token", TEST_API_TOKEN))
         .header(ContentType::ZIP)
         .body(compressed_data)
         .dispatch();
@@ -107,7 +110,7 @@ fn upload_test_file(client: &Client, file_name: &str) {
 
     let compressed = util::test::zip_data(&data).unwrap();
     let resp = client.post(format!("/api/event/current/file?name={file_name}"))
-        .header(Header::new("qx-api-token", API_TOKEN))
+        .header(Header::new("qx-api-token", TEST_API_TOKEN))
         .header(ContentType::ZIP)
         .body(compressed)
         .dispatch();
@@ -132,7 +135,7 @@ fn post_qe_change() {
 
     fn apply_change(client: &Client, run_id: DataId, change: &RunsRecord) -> RunsRecord {
         let resp = client.post(format!("/api/event/current/changes/run-updated?run_id={}", run_id.unwrap()))
-            .header(Header::new("qx-api-token", API_TOKEN))
+            .header(Header::new("qx-api-token", TEST_API_TOKEN))
             .header(ContentType::JSON)
             .json(&change)
             .dispatch();
diff --git a/templates/event-edit.html.hbs b/templates/event-edit.html.hbs
@@ -20,6 +20,14 @@
                             <b>Place</b>
                             <input class="w3-input w3-border w3-margin-bottom" type="text" placeholder="Enter event place" name="place" value="{{place}}" >
                         </label>
+                        <label>
+                            <b>Stage</b>
+                            <input class="w3-input w3-border w3-margin-bottom" type="number" name="stage" value="{{stage}}" >
+                        </label>
+                        <label>
+                            <b>Stage count</b>
+                            <input class="w3-input w3-border w3-margin-bottom" type="number" name="stage_count" value="{{stage_count}}" >
+                        </label>
                         <label>
                             <b>Start time</b>
                             <input class="w3-input w3-border w3-margin-bottom" type="text" placeholder="Enter event start date-time with UTC offset" name="start_time" value="{{start_time}}" >
diff --git a/templates/event.html.hbs b/templates/event.html.hbs
@@ -1,6 +1,6 @@
 {{#*inline "page"}}
 
-    <h2>{{ event.name }}</h2>
+    <h2>{{ event.name }} {{#if (gt event.stage_count 1)}} E{{ event.stage }} {{/if}}</h2>
     <div class="w3-bar">
         {{#if is_event_owner}}
             <a href="/event/{{event.id}}/edit" class="w3-button w3-theme w3-round-large w3-border"><i class="fa fa-cog"></i> edit</a>
diff --git a/templates/index.html.hbs b/templates/index.html.hbs
@@ -13,7 +13,7 @@
     <table class="w3-table-all w3-hoverable">
         {{#each events}}
             <tr>
-                <td><a href="/event/{{ this.id }}">{{this.name}}</a></td>
+                <td><a href="/event/{{ this.id }}">{{this.name}} {{#if (gt this.stage_count 1)}} E{{ this.stage }} {{/if}}</a></td>
                 <td>{{this.place}}</td>
                 <td>{{dtstr this.start_time}}</td>
                 <td>{{dtstr this.owner}}</td>
diff --git a/templates/startlist.html.hbs b/templates/startlist.html.hbs
@@ -72,10 +72,10 @@
             dlg.style.display='block'
         }
         function saveDialog(name, registration, si) {
-            let doc = document.getElementById('dlg')
+            let dlg = document.getElementById('dlg')
             let change = {}
             let add_change = fldname => {
-                let input = doc.querySelector(`input[name="${fldname}"]`);
+                let input = dlg.querySelector(`input[name="${fldname}"]`);
                 let new_val = input.value.trim()
                 if (new_val !== "") {
                     if (input.type === "number") {
@@ -100,8 +100,15 @@
                 else {
                     change.run_id = edited_entry.run_id;
                 }
+                let note = (() => {
+                    let input = dlg.querySelector(`input[name="note"]`);
+                    return input.value.trim()
+                })();
                 const params = new URLSearchParams();
                 params.append("data_id", change.run_id);
+                if (note) {
+                    params.append("note", note);
+                }
                 fetch(`/api/event/{{ event.id }}/changes/run-update-request?${params}`, {
                     method: 'POST',
                     body: JSON.stringify(change),

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+alter table events add column stage integer not null default 1;`
	`2`	`+alter table events add column stage_count integer not null default 1;`
	`3`	`+`