Remove endpoints upload/startlist and /api/event/current/upload/runs

Author: fvacek

db/migrations/20250621184259_changes_table_rename_run_id_to_data_id.sql

@@ -116,7 +116,7 @@ pub struct ChangesRecord {
     pub data: ChangeData,
     pub user_id: Option<String>,
     // we need run_id to be able to pair changes with rows in runs table
-    pub run_id: Option<i64>,
+    // pub run_id: Option<i64>,
     pub status: Option<ChangeStatus>,
     pub created: QxDateTime,
 }

src/changes.rs

@@ -4,10 +4,10 @@ use std::io::{Cursor, Read};
 use anyhow::anyhow;
 use image::ImageFormat;
 use rocket::form::{Contextual, Form};
-use rocket::http::{ContentType, Status};
+use rocket::http::{Status};
 use rocket::response::{Redirect};
 use rocket::response::status::Custom;
-use rocket::{Build, Data, Rocket, State};
+use rocket::{Build, Rocket, State};
 use rocket_dyn_templates::{context, Template};
 use sqlx::{query, query_as, FromRow, SqlitePool};
 use crate::db::{get_event_db, DbPool};
@@ -167,12 +167,12 @@ 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 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 {
@@ -308,7 +308,7 @@ async fn get_event_start_list(event_id: EventId, session_id: MaybeSessionId, cla
         .fetch_all(&edb).await.map_err(sqlx_to_custom_error)?;
     let changes = sqlx::query_as::<_, ChangesRecord>("SELECT changes.* FROM changes, runs
                  WHERE runs.class_name=?
-                   AND changes.run_id=runs.run_id
+                   AND changes.data_id=runs.run_id
                    AND changes.data_type=?
                    AND changes.status=?")
         .bind(&class_name)
@@ -362,25 +362,7 @@ async fn get_event_results(event_id: EventId, class_name: Option<&str>, state: &
     }))
 
 }
-#[post("/api/event/current/upload/startlist", data = "<data>")]
-async fn upload_start_list(qx_api_token: QxApiToken, data: Data<'_>, content_type: &ContentType, state: &State<SharedQxState>, gdb: &State<DbPool>) -> Result<String, Custom<String>> {
-    let event_info = load_event_info_for_api_token(&qx_api_token, gdb).await?;
-    let edb = get_event_db(event_info.id, state).await.map_err(anyhow_to_custom_error)?;
-    let file_id = crate::files::upload_file(qx_api_token, START_LIST_IOFXML3_FILE, data, content_type, state, gdb).await?;
-    import_start_list(event_info.id, &edb, gdb).await.map_err(anyhow_to_custom_error)?;
-    Ok(file_id.to_string())
-}
-#[post("/api/event/<event_id>/upload/startlist", data = "<data>")]
-async fn upload_start_list_user(event_id: EventId, data: Data<'_>, content_type: &ContentType, session_id: MaybeSessionId, state: &State<SharedQxState>, gdb: &State<DbPool>) -> Result<String, Custom<String>> {
-    let Some(_event_owner) = event_owner_opt(event_id, session_id, state, gdb).await.map_err(anyhow_to_custom_error)? else {
-        return Err(Custom(Status::Unauthorized, String::from("Session expired or not valid")));
-    };
-    let event_info = load_event_info(event_id, gdb).await?;
-    let edb = get_event_db(event_info.id, state).await.map_err(anyhow_to_custom_error)?;
-    let file_id = crate::files::upload_file(event_info.api_token, START_LIST_IOFXML3_FILE, data, content_type, state, gdb).await?;
-    import_start_list(event_info.id, &edb, gdb).await.map_err(anyhow_to_custom_error)?;
-    Ok(file_id.to_string())
-}
+
 pub async fn import_start_list(event_id: EventId, edb: &SqlitePool, gdb: &State<DbPool>) -> anyhow::Result<()> {
     let data = sqlx::query_as::<_, (Vec<u8>,)>("SELECT data FROM files WHERE name=?")
         .bind(START_LIST_IOFXML3_FILE)
@@ -432,15 +414,6 @@ pub async fn import_start_list(event_id: EventId, edb: &SqlitePool, gdb: &State<
     Ok(())
 }
 
-#[post("/api/event/current/upload/runs", data = "<data>")]
-async fn upload_runs(qx_api_token: QxApiToken, data: Data<'_>, content_type: &ContentType, state: &State<SharedQxState>, gdb: &State<DbPool>) -> Result<String, Custom<String>> {
-    let event_info = load_event_info_for_api_token(&qx_api_token, gdb).await?;
-    let edb = get_event_db(event_info.id, state).await.map_err(anyhow_to_custom_error)?;
-    let file_id = crate::files::upload_file(qx_api_token, RUNS_CSV_FILE, data, content_type, state, gdb).await?;
-    import_runs(&edb).await.map_err(anyhow_to_custom_error)?;
-    Ok(file_id)
-}
-
 pub async fn import_runs(edb: &SqlitePool) -> anyhow::Result<()> {
     let data = load_file_from_db(RUNS_CSV_FILE, edb).await?;
     let mut rdr = csv::Reader::from_reader(&*data);
@@ -526,13 +499,10 @@ pub fn extend(rocket: Rocket<Build>) -> Rocket<Build> {
             event_delete,
             post_event,
             get_event,
-            upload_start_list,
-            upload_start_list_user,
             get_event_start_list,
             get_event_results,
             get_api_event_current,
             post_api_event_current,
-            upload_runs,
         ])
 }
 

src/event.rs

@@ -6,7 +6,7 @@ use rocket::response::status::{Custom};
 use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
 use crate::db::{get_event_db, DbPool};
-use crate::event::{load_event_info_for_api_token, EventId};
+use crate::event::{import_runs, import_start_list, load_event_info_for_api_token, EventId, RUNS_CSV_FILE, START_LIST_IOFXML3_FILE};
 use crate::{QxApiToken, SharedQxState};
 use crate::util::{anyhow_to_custom_error, sqlx_to_anyhow, sqlx_to_custom_error, unzip_data};
 
@@ -83,6 +83,12 @@ pub async fn upload_file(qx_api_token: QxApiToken, name: &str, data: Data<'_>, c
         data
     };
     let file_id = save_file_to_db(name, &data, &edb).await.map_err(anyhow_to_custom_error)?;
+    if name == START_LIST_IOFXML3_FILE {
+        import_start_list(event_info.id, &edb, gdb).await.map_err(anyhow_to_custom_error)?;
+    }
+    else if name == RUNS_CSV_FILE {
+        import_runs(&edb).await.map_err(anyhow_to_custom_error)?;
+    }
     Ok(format!("{file_id}"))
 }
 pub fn extend(rocket: Rocket<Build>) -> Rocket<Build> {

src/files.rs

@@ -100,23 +100,26 @@ fn upload_file() {
     assert!(files.iter().find(|f| f.name == file_name).is_none());
 }
 
-fn upload_start_list_impl(client: &Client) {
-    let mut file = OpenOptions::new().read(true).open(format!("tests/{START_LIST_IOFXML3_FILE}")).unwrap();
+fn upload_test_file(client: &Client, file_name: &str) {
+    let mut file = OpenOptions::new().read(true).open(format!("tests/{file_name}")).unwrap();
     let mut data = vec![];
     file.read_to_end(&mut data).unwrap();
 
     let compressed = util::test::zip_data(&data).unwrap();
-    let resp = client.post("/api/event/current/upload/startlist")
+    let resp = client.post(format!("/api/event/current/file?name={file_name}"))
         .header(Header::new("qx-api-token", API_TOKEN))
         .header(ContentType::ZIP)
         .body(compressed)
         .dispatch();
     assert_eq!(resp.status(), Status::Ok);
 }
+fn upload_start_list(client: &Client) {
+    upload_test_file(&client, START_LIST_IOFXML3_FILE);
+}
 #[test]
-fn upload_start_list() {
+fn test_upload_start_list() {
     let client = create_test_server();
-    upload_start_list_impl(&client);
+    upload_start_list(&client);
     // get start list page
     let resp = client.get(format!("/event/{EVENT_ID}/startlist")).dispatch();
     assert_eq!(resp.status(), Status::Ok);
@@ -125,7 +128,7 @@ fn upload_start_list() {
 #[test]
 fn post_qe_change() {
     let client = create_test_server();
-    upload_start_list_impl(&client);
+    upload_start_list(&client);
 
     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()))

src/tests.rs

@@ -8,7 +8,7 @@
         <tr class="w3-theme-l1">
             <th>Status</th>
             <th>Data</th>
-            <th class="w3-right-align">Run Id</th>
+            <th class="w3-right-align">Data Id</th>
             <th>Source</th>
             <th>User ID</th>
             <th>Created</th>
@@ -19,7 +19,7 @@
             <tr>
                 <td>{{ stringify status }}</td>
                 <td>{{ stringify data }}</td>
-                <td class="w3-right-align">{{ run_id }}</td>
+                <td class="w3-right-align">{{ data_id }}</td>
                 <td>{{ source }}</td>
                 <td>{{ user_id }}</td>
                 <td>{{ created }}</td>

templates/changes.html.hbs

@@ -139,7 +139,9 @@
             else {
                 change.run_id = edited_entry.run_id;
             }
-            fetch('/api/event/{{ event.id }}/changes/run-update-request', {
+            const params = new URLSearchParams();
+            params.append("data_id", change.run_id);
+            fetch(`/api/event/{{ event.id }}/changes/run-update-request?${params}`, {
                 method: 'POST',
                 body: JSON.stringify(change),
                 headers: {