Implement data entry abort modal behaviour (#256)

Co-authored-by: Joep Schuurkes <[email protected]>

Author: praseodym

backend/openapi.json

@@ -207,7 +207,7 @@
         "tags": [
           "polling_station"
         ],
-        "summary": "Save or update the data entry for a polling station",
+        "summary": "Save or update a data entry for a polling station",
         "operationId": "polling_station_data_entry",
         "parameters": [
           {
@@ -295,6 +295,62 @@
             }
           }
         }
+      },
+      "delete": {
+        "tags": [
+          "polling_station"
+        ],
+        "summary": "Delete an in-progress (not finalised) data entry for a polling station",
+        "operationId": "polling_station_data_entry_delete",
+        "parameters": [
+          {
+            "name": "polling_station_id",
+            "in": "path",
+            "description": "Polling station database id",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32",
+              "minimum": 0
+            }
+          },
+          {
+            "name": "entry_number",
+            "in": "path",
+            "description": "Data entry number (first or second data entry)",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32",
+              "minimum": 0
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Data entry deleted successfully"
+          },
+          "404": {
+            "description": "Not found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          }
+        }
       }
     },
     "/api/polling_stations/{polling_station_id}/data_entries/{entry_number}/finalise": {

backend/src/lib.rs

@@ -5,7 +5,7 @@ use axum::extract::rejection::JsonRejection;
 use axum::extract::FromRef;
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
-use axum::routing::{get, post};
+use axum::routing::{delete, get, post};
 use axum::{Json, Router};
 use serde::{Deserialize, Serialize};
 use sqlx::Error::RowNotFound;
@@ -32,6 +32,10 @@ pub fn router(pool: SqlitePool) -> Result<Router, Box<dyn Error>> {
             "/:polling_station_id/data_entries/:entry_number",
             post(polling_station::polling_station_data_entry),
         )
+        .route(
+            "/:polling_station_id/data_entries/:entry_number",
+            delete(polling_station::polling_station_data_entry_delete),
+        )
         .route(
             "/:polling_station_id/data_entries/:entry_number/finalise",
             post(polling_station::polling_station_data_entry_finalise),
@@ -73,6 +77,7 @@ pub fn create_openapi() -> utoipa::openapi::OpenApi {
             election::election_status,
             polling_station::polling_station_list,
             polling_station::polling_station_data_entry,
+            polling_station::polling_station_data_entry_delete,
             polling_station::polling_station_data_entry_finalise,
         ),
         components(

backend/src/polling_station/mod.rs

@@ -1,4 +1,5 @@
 use axum::extract::{FromRequest, Path, State};
+use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
 use axum::Json;
 use serde::{Deserialize, Serialize};
@@ -35,7 +36,7 @@ impl IntoResponse for DataEntryResponse {
     }
 }
 
-/// Save or update the data entry for a polling station
+/// Save or update a data entry for a polling station
 #[utoipa::path(
     post,
     path = "/api/polling_stations/{polling_station_id}/data_entries/{entry_number}",
@@ -84,6 +85,38 @@ pub async fn polling_station_data_entry(
     Ok(DataEntryResponse { validation_results })
 }
 
+/// Delete an in-progress (not finalised) data entry for a polling station
+#[utoipa::path(
+    delete,
+    path = "/api/polling_stations/{polling_station_id}/data_entries/{entry_number}",
+    responses(
+        (status = 204, description = "Data entry deleted successfully"),
+        (status = 404, description = "Not found", body = ErrorResponse),
+        (status = 500, description = "Internal server error", body = ErrorResponse),
+    ),
+    params(
+        ("polling_station_id" = u32, description = "Polling station database id"),
+        ("entry_number" = u8, description = "Data entry number (first or second data entry)"),
+    ),
+)]
+pub async fn polling_station_data_entry_delete(
+    State(polling_station_data_entries): State<PollingStationDataEntries>,
+    Path((id, entry_number)): Path<(u32, u8)>,
+) -> Result<StatusCode, APIError> {
+    // only the first data entry is supported for now
+    if entry_number != 1 {
+        return Err(APIError::NotFound(
+            "Only the first data entry is supported".to_string(),
+        ));
+    }
+
+    polling_station_data_entries
+        .delete(id, entry_number)
+        .await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
+
 /// Finalise the data entry for a polling station
 #[utoipa::path(
     post,
@@ -169,13 +202,13 @@ pub async fn polling_station_list(
 
 #[cfg(test)]
 mod tests {
+    use axum::http::StatusCode;
     use sqlx::{query, SqlitePool};
 
     use super::*;
 
-    #[sqlx::test(fixtures("../../fixtures/elections.sql", "../../fixtures/polling_stations.sql"))]
-    async fn test_polling_station_data_entry_valid(pool: SqlitePool) {
-        let mut request_body = DataEntryRequest {
+    fn example_data_entry() -> DataEntryRequest {
+        DataEntryRequest {
             data: PollingStationResults {
                 recounted: false,
                 voters_counts: VotersCounts {
@@ -215,7 +248,12 @@ mod tests {
                     ],
                 }],
             },
-        };
+        }
+    }
+
+    #[sqlx::test(fixtures("../../fixtures/elections.sql", "../../fixtures/polling_stations.sql"))]
+    async fn test_polling_station_data_entry_valid(pool: SqlitePool) {
+        let mut request_body = example_data_entry();
 
         async fn save(pool: SqlitePool, request_body: DataEntryRequest) -> Response {
             polling_station_data_entry(
@@ -242,7 +280,7 @@ mod tests {
         }
 
         let response = save(pool.clone(), request_body.clone()).await;
-        assert_eq!(response.status(), 200);
+        assert_eq!(response.status(), StatusCode::OK);
 
         // Check if a row was created
         let row_count = query!("SELECT COUNT(*) AS count FROM polling_station_data_entries")
@@ -253,15 +291,15 @@ mod tests {
 
         // Check that we cannot finalise with errors
         let response = save(pool.clone(), request_body.clone()).await;
-        assert_eq!(response.status(), 200);
+        assert_eq!(response.status(), StatusCode::OK);
         let response = finalise(pool.clone()).await;
-        assert_eq!(response.status(), 409);
+        assert_eq!(response.status(), StatusCode::CONFLICT);
 
         // Test updating the data entry
         let poll_card_count = 98;
         request_body.data.voters_counts.poll_card_count = poll_card_count; // correct value
         let response = save(pool.clone(), request_body.clone()).await;
-        assert_eq!(response.status(), 200);
+        assert_eq!(response.status(), StatusCode::OK);
 
         // Check if there is still only one row
         let row_count = query!("SELECT COUNT(*) AS count FROM polling_station_data_entries")
@@ -280,9 +318,9 @@ mod tests {
 
         // Finalise data entry after correcting the error
         let response = save(pool.clone(), request_body.clone()).await;
-        assert_eq!(response.status(), 200);
+        assert_eq!(response.status(), StatusCode::OK);
         let response = finalise(pool.clone()).await;
-        assert_eq!(response.status(), 200);
+        assert_eq!(response.status(), StatusCode::OK);
 
         // Check if the data entry was finalised:
         // removed from polling_station_data_entries...
@@ -299,6 +337,46 @@ mod tests {
         assert_eq!(row_count.count, 1);
     }
 
+    #[sqlx::test(fixtures("../../fixtures/elections.sql", "../../fixtures/polling_stations.sql"))]
+    async fn test_polling_station_data_entry_delete(pool: SqlitePool) {
+        // create data entry
+        let response = polling_station_data_entry(
+            State(PollingStationDataEntries::new(pool.clone())),
+            State(PollingStations::new(pool.clone())),
+            State(Elections::new(pool.clone())),
+            Path((1, 1)),
+            example_data_entry(),
+        )
+        .await
+        .into_response();
+        assert_eq!(response.status(), StatusCode::OK);
+
+        // delete data entry
+        let response = polling_station_data_entry_delete(
+            State(PollingStationDataEntries::new(pool.clone())),
+            Path((1, 1)),
+        )
+        .await
+        .into_response();
+        assert_eq!(response.status(), StatusCode::NO_CONTENT);
+
+        // check if data entry was deleted
+        let row_count = query!("SELECT COUNT(*) AS count FROM polling_station_data_entries")
+            .fetch_one(&pool)
+            .await
+            .unwrap();
+        assert_eq!(row_count.count, 0);
+
+        // check that deleting a non-existing data entry returns 404
+        let response = polling_station_data_entry_delete(
+            State(PollingStationDataEntries::new(pool.clone())),
+            Path((1, 1)),
+        )
+        .await
+        .into_response();
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    }
+
     #[sqlx::test(fixtures("../../fixtures/elections.sql"))]
     async fn test_polling_station_number_unique_per_election(pool: SqlitePool) {
         // Insert two unique polling stations

backend/src/polling_station/repository.rs

@@ -118,6 +118,21 @@ impl PollingStationDataEntries {
         res.data.ok_or_else(|| sqlx::Error::RowNotFound)
     }
 
+    pub async fn delete(&self, id: u32, entry_number: u8) -> Result<(), sqlx::Error> {
+        let res = query!(
+            "DELETE FROM polling_station_data_entries WHERE polling_station_id = ? AND entry_number = ?",
+            id,
+            entry_number
+        )
+        .execute(&self.0)
+        .await?;
+        if res.rows_affected() == 0 {
+            Err(sqlx::Error::RowNotFound)
+        } else {
+            Ok(())
+        }
+    }
+
     pub async fn finalise(
         &self,
         tx: &mut Transaction<'_, Sqlite>,

backend/tests/data_entries_integration_test.rs

@@ -1,13 +1,11 @@
 #![cfg(test)]
 
-use reqwest::StatusCode;
+use reqwest::{Response, StatusCode};
 use serde_json::json;
 use sqlx::SqlitePool;
+use std::net::SocketAddr;
 
-use backend::polling_station::{
-    CandidateVotes, DataEntryRequest, DataEntryResponse, DifferencesCounts, PoliticalGroupVotes,
-    PollingStationResults, VotersCounts, VotesCounts,
-};
+use backend::polling_station::DataEntryResponse;
 use backend::validation::ValidationResultCode;
 use backend::ErrorResponse;
 
@@ -156,48 +154,7 @@ async fn test_polling_station_data_entry_invalid(pool: SqlitePool) {
 async fn test_polling_station_data_entry_only_for_existing(pool: SqlitePool) {
     let addr = serve_api(pool).await;
 
-    let request_body = DataEntryRequest {
-        data: PollingStationResults {
-            recounted: false,
-            voters_counts: VotersCounts {
-                poll_card_count: 100,
-                proxy_certificate_count: 2,
-                voter_card_count: 2,
-                total_admitted_voters_count: 104,
-            },
-            votes_counts: VotesCounts {
-                votes_candidates_counts: 102,
-                blank_votes_count: 1,
-                invalid_votes_count: 1,
-                total_votes_cast_count: 104,
-            },
-            voters_recounts: None,
-            differences_counts: DifferencesCounts {
-                more_ballots_count: 0,
-                fewer_ballots_count: 0,
-                unreturned_ballots_count: 0,
-                too_few_ballots_handed_out_count: 0,
-                too_many_ballots_handed_out_count: 0,
-                other_explanation_count: 0,
-                no_explanation_count: 0,
-            },
-            political_group_votes: vec![PoliticalGroupVotes {
-                number: 1,
-                total: 102,
-                candidate_votes: vec![
-                    CandidateVotes {
-                        number: 1,
-                        votes: 54,
-                    },
-                    CandidateVotes {
-                        number: 2,
-                        votes: 48,
-                    },
-                ],
-            }],
-        },
-    };
-
+    let request_body = shared::example_data_entry();
     let invalid_id = 123_456_789;
 
     let url = format!("http://{addr}/api/polling_stations/{invalid_id}/data_entries/1");
@@ -219,3 +176,32 @@ async fn test_polling_station_data_entry_only_for_existing(pool: SqlitePool) {
     // Ensure the response is what we expect
     assert_eq!(response.status(), StatusCode::NOT_FOUND);
 }
+
+#[sqlx::test(fixtures("../fixtures/elections.sql", "../fixtures/polling_stations.sql"))]
+async fn test_polling_station_data_entry_deletion(pool: SqlitePool) {
+    let addr = serve_api(pool).await;
+
+    let request_body = shared::example_data_entry();
+
+    // create a data entry
+    let url = format!("http://{addr}/api/polling_stations/1/data_entries/1");
+    let response = reqwest::Client::new()
+        .post(&url)
+        .json(&request_body)
+        .send()
+        .await
+        .unwrap();
+    assert_eq!(response.status(), StatusCode::OK);
+
+    // delete the data entry
+    async fn delete_data_entry(addr: SocketAddr) -> Response {
+        let url = format!("http://{addr}/api/polling_stations/1/data_entries/1");
+        reqwest::Client::new().delete(&url).send().await.unwrap()
+    }
+    let response = delete_data_entry(addr).await;
+    assert_eq!(response.status(), StatusCode::NO_CONTENT);
+
+    // delete a non-existing data entry
+    let response = delete_data_entry(addr).await;
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
+}