Endpoints seem to work now

Author: BoySanic

common/src/errors/validate_err_error.rs

@@ -3,10 +3,14 @@ use thiserror::Error;
 
 #[derive(Clone, Hash, Debug, Serialize, Deserialize, Error)]
 pub enum ValidateErrError {
-    #[error("invalid task")]
-    InvalidTask,
+    #[error("invalid assignment")]
+    InvalidAssignment,
     #[error("provided assignments needed value out of bounds")]
     AssignmentsNeededOutOfBounds,
     #[error("canonical result already set")]
     CanonicalResultExists,
+    #[error("provided assignmennts belong to multiple tasks")]
+    AssignmentTaskRelationshipError,
+    #[error("provided inconclusive assignments belong to different tasks than the error assignments")]
+    RequestAssignmentsRelationshipError,
 }

common/src/errors/validate_ok_error.rs

@@ -7,8 +7,8 @@ pub enum ValidateOkError {
     InvalidAssignment,
     #[error("canonical result already set")]
     CanonicalResultExists,
-    #[error("provided results belong to multiple tasks")]
-    ResultTaskRelationshipInconsistent,
+    #[error("provided assignments belong to multiple tasks")]
+    AssignmentTaskRelationshipError,
     #[error("result count does not equal quorum")]
     ResultCountQuorumNotEqual,
     #[error("assignments which have been canceled cannot be validated")]

common/src/requests/validate_err_request.rs

@@ -1,10 +1,10 @@
 use serde::{Deserialize, Serialize};
 
-use crate::types::Assignment;
+use crate::{id::Id, types::Assignment};
 
 #[derive(Clone, Hash, Debug, Serialize, Deserialize)]
 pub struct ValidateErrRequest {
     pub assignments_needed: i32,
-    pub assignments_error: Vec<Assignment>,
-    pub assignments_inconclusive: Vec<Assignment>,
+    pub assignments_error: Vec<Id<Assignment>>,
+    pub assignments_inconclusive: Vec<Id<Assignment>>,
 }

server/src/main.rs

@@ -68,8 +68,8 @@ async fn main() {
         .route("/fetch_tasks", post(fetch_tasks::fetch_tasks))
         .route("/submit_result/{id}", post(submit_result::submit_result))
         .route("/validate_fetch", post(validate_fetch::validate_fetch))
-        .route("/validate_ok/{id}", post(validate_ok::validate_ok))
-        .route("/validate_err/{id}", post(validate_err::validate_err))
+        .route("/validate_ok", post(validate_ok::validate_ok))
+        .route("/validate_err", post(validate_err::validate_err))
         .with_state(state);
 
     let listener = TcpListener::bind(address).await.unwrap();

server/src/result.rs

@@ -63,7 +63,7 @@ impl Status for ValidateOkError {
             Self::CanonicalResultExists => StatusCode::BAD_REQUEST,
             Self::AssignmentCanceledError => StatusCode::BAD_REQUEST,
             Self::ResultCountQuorumNotEqual => StatusCode::BAD_REQUEST,
-            Self::ResultTaskRelationshipInconsistent => StatusCode::BAD_REQUEST,
+            Self::AssignmentTaskRelationshipError => StatusCode::BAD_REQUEST,
         }
     }
 }
@@ -72,8 +72,10 @@ impl Status for ValidateErrError {
     fn status(&self) -> StatusCode {
         match self {
             Self::AssignmentsNeededOutOfBounds => StatusCode::BAD_REQUEST,
-            Self::InvalidTask => StatusCode::NOT_FOUND,
+            Self::InvalidAssignment => StatusCode::NOT_FOUND,
             Self::CanonicalResultExists => StatusCode::BAD_REQUEST,
+            Self::AssignmentTaskRelationshipError => StatusCode::BAD_REQUEST,
+            Self::RequestAssignmentsRelationshipError => StatusCode::BAD_REQUEST
         }
     }
 }
@@ -152,7 +154,7 @@ impl From<sqlx::Error> for AppError<ValidateOkError> {
 impl From<sqlx::Error> for AppError<ValidateErrError> {
     fn from(err: sqlx::Error) -> Self {
         match err {
-            sqlx::Error::RowNotFound => Self::Specific(ValidateErrError::InvalidTask),
+            sqlx::Error::RowNotFound => Self::Specific(ValidateErrError::InvalidAssignment),
             _ => Self::Generic,
         }
     }

server/src/routes/submit_result.rs

@@ -18,8 +18,8 @@ pub async fn submit_result(
     Json(request): Json<SubmitResultRequest>,
 ) -> AppResult<(), SubmitResultError> {
     // TODO: fix race condition: assignment could get canceled before result is inserted
-    println!("Test");
-    let assignment_query = sqlx::query_scalar_unchecked!(
+
+    let assignment_id = sqlx::query_scalar_unchecked!(
         r#"
         SELECT
             id "id: Id<Assignment>"
@@ -60,6 +60,6 @@ pub async fn submit_result(
     )
     .execute(&state.pool)
     .await?;
-println!("Test4");
+
     Ok(())
 }

server/src/routes/validate_err.rs

@@ -18,20 +18,90 @@ use crate::{
 
 pub async fn validate_err(
     State(state): State<AppState>,
-    Path(task_id): Path<Id<Task>>,
     Json(request): Json<ValidateErrRequest>,
 ) -> AppResult<(), ValidateErrError> {
-    let task = Task::select_one(task_id).fetch_one(&state.pool).await?;
 
-    if task.canonical_result_id.is_some() {
+    let assignments_error = sqlx::query_as_unchecked!(
+        Assignment,
+        r#"
+            SELECT
+                *
+            FROM
+                assignments
+            WHERE
+                id = ANY($1)
+        "#,
+        request.assignments_error
+    )
+    .fetch_all(&state.pool)
+    .await?;
+
+
+    let assignments_inconclusive = sqlx::query_as_unchecked!(
+        Assignment,
+        r#"
+            SELECT
+                *
+            FROM
+                assignments
+            WHERE
+                id = ANY($1)
+        "#,
+        request.assignments_inconclusive
+    )
+    .fetch_all(&state.pool)
+    .await?;
+
+    if assignments_inconclusive.len() != request.assignments_inconclusive.len() || assignments_error.len() != request.assignments_error.len() {
+        Err(ValidateErrError::InvalidAssignment)?;
+    }
+
+    let mut task_error_ids = Vec::from_iter(assignments_error.into_iter().map(|assignment| assignment.task_id));
+    task_error_ids.sort();
+    task_error_ids.dedup();
+
+    let mut task_inconclusive_ids = Vec::from_iter(assignments_inconclusive.into_iter().map(|assignment| assignment.task_id));
+    task_inconclusive_ids.sort();
+    task_inconclusive_ids.dedup();
+
+    if task_error_ids.len() > 1 || task_inconclusive_ids.len() > 1 {
+        Err(ValidateErrError::AssignmentTaskRelationshipError)?
+    }
+    
+    if task_error_ids[0] != task_inconclusive_ids[0]{
+        Err(ValidateErrError::RequestAssignmentsRelationshipError)?
+    }
+
+    let task_error = Task::select_one(task_error_ids[0]).fetch_one(&state.pool).await?;
+    let task_inconclusive = Task::select_one(task_inconclusive_ids[0]).fetch_one(&state.pool).await?;
+
+    if task_error.canonical_result_id.is_some() || task_inconclusive.canonical_result_id.is_some() {
         Err(ValidateErrError::CanonicalResultExists)?
     }
 
-    let project = Project::select_one(task.project_id)
+    let project_inconclusive = Project::select_one(task_inconclusive.project_id)
         .fetch_one(&state.pool)
         .await?;
 
-    let result_count = sqlx::query_scalar_unchecked!(
+    let result_error_count = sqlx::query_scalar_unchecked!(
+        r#"
+            SELECT
+                count(1) as "count!"
+            FROM
+                results r
+            JOIN assignments a
+                ON a.id = r.assignment_id
+            JOIN tasks t
+                ON t.id = a.task_id
+            WHERE
+                t.id = $1
+        "#,
+        task_error.id
+    )
+    .fetch_one(&state.pool)
+    .await? as i32;
+
+    let result_inconclusive_count = sqlx::query_scalar_unchecked!(
         r#"
             SELECT
                 count(1) as "count!"
@@ -44,13 +114,13 @@ pub async fn validate_err(
             WHERE
                 t.id = $1
         "#,
-        task_id
+        task_inconclusive.id
     )
     .fetch_one(&state.pool)
     .await? as i32;
 
     if request.assignments_needed <= 0
-        || request.assignments_needed + task.assignments_needed > project.quorum + result_count
+        || request.assignments_needed + task_inconclusive.assignments_needed > project_inconclusive.quorum + result_inconclusive_count + result_error_count
     {
         Err(ValidateErrError::AssignmentsNeededOutOfBounds)?
     } else {
@@ -62,23 +132,25 @@ pub async fn validate_err(
             WHERE
                 id = $1
             "#,
-            task_id,
+            task_inconclusive.id,
             request.assignments_needed
         )
         .execute(&state.pool)
         .await?;
 
-        //Set validate state
+        //Set inconclusive validate state
         set_assignment_state::set_assignment_state(
             &state,
             AssignmentState::Inconclusive,
-            &Vec::from_iter(
-                Assignment::select_all_by(task_id)
-                    .fetch_all(&state.pool)
-                    .await?
-                    .iter()
-                    .map(|assignment| assignment.id),
-            ),
+            &request.assignments_inconclusive,
+        )
+        .await?;
+
+        //Set invalid validate state
+        set_assignment_state::set_assignment_state(
+            &state,
+            AssignmentState::Invalid,
+            &request.assignments_error,
         )
         .await?;
     }

server/src/routes/validate_fetch.rs

@@ -47,7 +47,7 @@ pub async fn validate_fetch(
         "#,
         request.project_ids,
     )
-    .fetch_optional(&state.pool)
+    .fetch_all(&state.pool)
     .await?;
 
     Ok(Json(task.into_iter().collect()))

server/src/routes/validate_ok.rs

@@ -25,7 +25,7 @@ pub async fn validate_ok(
     )
     .fetch_all(&state.pool)
     .await?;
-
+    println!("Request: {}\t db: {}", request.assignment_ids.len(), assignments.len());
     if assignments.len() != request.assignment_ids.len() {
         Err(ValidateOkError::InvalidAssignment)?;
     }
@@ -35,7 +35,7 @@ pub async fn validate_ok(
     task_ids.dedup();
 
     if task_ids.len() > 1 || task_ids.is_empty() {
-        Err(ValidateOkError::ResultTaskRelationshipInconsistent)?;
+        Err(ValidateOkError::AssignmentTaskRelationshipError)?;
     }
 
     let task = Task::select_one(task_ids[0]).fetch_one(&state.pool).await?;
@@ -95,10 +95,10 @@ pub async fn validate_ok(
             LEFT JOIN results r
                 ON r.assignment_id = a.id
             WHERE
-                a.id  <> ANY($1)
+                a.state != $1
                 AND task_id = $2
         "#,
-        request.assignment_ids,
+        AssignmentState::Valid,
         task.id
     )
     .fetch_all(&state.pool)

server/src/util/set_assignment_state.rs

@@ -25,6 +25,5 @@ pub async fn set_assignment_state(
     )
     .execute(&state.pool)
     .await?;
-    println!("test2");
     Ok(())
 }