✨ Add is_completed column to histories

Author: KrLite

entity/src/entities/histories.rs

@@ -18,6 +18,7 @@ pub struct Model {
     pub submit_history: Option<SubmitHistory>,
     pub original_solution: PuzzleSolution,
     pub is_dirty: bool,
+    pub is_completed: bool,
     pub uploaded_at: DateTime,
 }
 

entity/src/types/submit_word.rs

@@ -72,6 +72,10 @@ impl<const N: usize> SubmitWord<N> {
         false
     }
 
+    pub fn all_matches(&self) -> bool {
+        self.0.iter().all(|l| l.matches == Matches::Yes)
+    }
+
     pub fn to_vec(&self) -> Vec<&SubmitLetter> {
         self.0.iter().collect()
     }

migration/src/lib.rs

@@ -1,12 +1,16 @@
 pub use sea_orm_migration::prelude::*;
 
 mod m20220101_000001_create_table;
+mod m20250817_081620_alter_table;
 
 pub struct Migrator;
 
 #[async_trait::async_trait]
 impl MigratorTrait for Migrator {
     fn migrations() -> Vec<Box<dyn MigrationTrait>> {
-        vec![Box::new(m20220101_000001_create_table::Migration)]
+        vec![
+            Box::new(m20220101_000001_create_table::Migration),
+            Box::new(m20250817_081620_alter_table::Migration),
+        ]
     }
 }

migration/src/m20250817_081620_alter_table.rs

@@ -0,0 +1,35 @@
+use sea_orm_migration::{prelude::*, schema::*};
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Histories::Table)
+                    .add_column_if_not_exists(boolean(Histories::IsCompleted).default(false))
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .alter_table(
+                Table::alter()
+                    .table(Histories::Table)
+                    .drop_column(Histories::IsCompleted)
+                    .to_owned(),
+            )
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum Histories {
+    Table,
+    IsCompleted,
+}

src/database/tables/histories.rs

@@ -11,7 +11,7 @@ use sea_orm::{
     ActiveValue, ColumnTrait, Condition, DatabaseConnection, DbErr, EntityTrait, IntoActiveModel,
     QueryFilter, QuerySelect,
 };
-use tracing::{error, info, trace, warn};
+use tracing::{error, info, warn};
 
 pub async fn get_history(
     db: &DatabaseConnection,
@@ -64,9 +64,9 @@ pub async fn create_history(
 
 #[derive(Debug, Clone)]
 pub struct SubmitResult {
-    pub remaining_tries: usize,
-    pub is_dirty: bool,
     pub submit_history: SubmitHistory,
+    pub is_dirty: bool,
+    pub is_completed: bool,
 }
 
 pub async fn submit_to_history(
@@ -83,15 +83,24 @@ pub async fn submit_to_history(
             .columns([
                 histories::Column::SubmitHistory,
                 histories::Column::IsDirty,
+                histories::Column::IsCompleted,
                 histories::Column::OriginalSolution,
             ])
-            .into_tuple::<(Option<SubmitHistory>, bool, PuzzleSolution)>()
+            .into_tuple::<(Option<SubmitHistory>, bool, bool, PuzzleSolution)>()
             .one(db)
             .await
             .ok()
             .flatten()
         {
-            Some((submit_history, is_dirty, solution)) => {
+            Some((submit_history, is_dirty, true, _)) => {
+                warn!("history is completed for {date} with session {session}!");
+                return Ok(SubmitResult {
+                    submit_history: submit_history.unwrap_or_default(),
+                    is_dirty,
+                    is_completed: true,
+                });
+            }
+            Some((submit_history, is_dirty, false, solution)) => {
                 (submit_history.unwrap_or_default(), is_dirty, solution)
             }
             None => {
@@ -100,8 +109,9 @@ pub async fn submit_to_history(
             }
         };
 
+    let word = SubmitWord::tint(answer, &solution);
     submit_history
-        .submit(SubmitWord::tint(answer, &solution))
+        .submit(word)
         .map_err(|e| DbErr::Custom(e.to_string()))?;
 
     let active_history = histories::ActiveModel {
@@ -110,14 +120,17 @@ pub async fn submit_to_history(
         submit_history: ActiveValue::Set(Some(submit_history.clone())),
         original_solution: ActiveValue::Unchanged(solution),
         is_dirty: ActiveValue::Unchanged(false),
+        is_completed: ActiveValue::Set(word.all_matches()),
         uploaded_at: ActiveValue::Unchanged(Utc::now().naive_utc()),
-        ..Default::default()
     };
 
     match Histories::insert(active_history)
         .on_conflict(
             OnConflict::columns([histories::Column::Date, histories::Column::Session])
-                .update_column(histories::Column::SubmitHistory)
+                .update_columns([
+                    histories::Column::SubmitHistory,
+                    histories::Column::IsCompleted,
+                ])
                 .to_owned(),
         )
         .exec(db)
@@ -126,9 +139,9 @@ pub async fn submit_to_history(
         Ok(_) => {
             info!("submitted {answer} to history at {date} with session {session}");
             Ok(SubmitResult {
-                remaining_tries: submit_history.remaining_tries(),
-                is_dirty,
                 submit_history,
+                is_dirty,
+                is_completed: word.all_matches(),
             })
         }
         Err(err) => {

src/endpoint/play/start/mod.rs

@@ -28,6 +28,7 @@ pub struct GetParams {
 pub struct GetResponse {
     remaining_tries: usize,
     is_dirty: bool,
+    is_completed: bool,
     history: Vec<SubmitWord>,
 }
 
@@ -58,6 +59,7 @@ pub async fn get(
             Json(GetResponse {
                 remaining_tries: history.remaining_tries(),
                 is_dirty: history.is_dirty,
+                is_completed: history.is_completed,
                 history: history
                     .submit_history
                     .map(SubmitHistory::into_vec)
@@ -94,6 +96,7 @@ pub async fn get(
                     Json(GetResponse {
                         remaining_tries: HISTORY_MAX_TRIES,
                         is_dirty: false,
+                        is_completed: false,
                         ..Default::default()
                     }),
                 )

src/endpoint/play/submit/mod.rs

@@ -24,6 +24,7 @@ pub struct PostPayload {
 pub struct PostResponse {
     remaining_tries: usize,
     is_dirty: bool,
+    is_completed: bool,
     history: Vec<SubmitWord>,
 }
 
@@ -51,8 +52,9 @@ pub async fn post(
         Ok(result) => (
             StatusCode::ACCEPTED,
             Json(PostResponse {
-                remaining_tries: result.remaining_tries,
+                remaining_tries: result.submit_history.remaining_tries(),
                 is_dirty: result.is_dirty,
+                is_completed: result.is_completed,
                 history: result.submit_history.into_vec(),
             }),
         )