Feat active updater

persistence/dao/ceobe-operate/src/sql/announcement/update.rs

@@ -1,6 +1,7 @@
 use db_ops_prelude::{
+    ext_traits::with_field::{FieldOrder, With},
     get_connect::{GetDatabaseTransaction, TransactionOps},
-    sea_orm::{ConnectionTrait, DbErr, EntityTrait},
+    sea_orm::{ConnectionTrait, DbErr, EntityTrait, IntoActiveModel},
 };
 use tracing::{info, instrument};
 
@@ -28,10 +29,9 @@ where
         // 处理数据，添加order
         let announcement_list = announcements.into_iter().enumerate().map(
             |(order, announcement)| {
-                super::ActiveModel::from_announcement_data_with_order(
-                    announcement,
-                    order as i32,
-                )
+                announcement
+                    .with(FieldOrder, order as _)
+                    .into_active_model()
             },
         );
         // 新建数据

persistence/dao/ceobe-operate/src/sql/video/update.rs

@@ -2,20 +2,22 @@ use std::collections::HashMap;
 
 use db_ops_prelude::{
     database_operates::NoConnect,
+    ext_traits::{
+        with_field::{FieldOrder, With},
+        UpdateActiveModel,
+    },
     futures::{future::ok, stream::iter, StreamExt, TryStreamExt},
     get_connect::{GetDatabaseTransaction, TransactionOps},
     get_now_naive_date_time_value, get_zero_data_time,
     sea_orm::{
         sea_query::Expr, ActiveModelTrait, ColumnTrait, ConnectionTrait,
         DbErr, EntityTrait, IntoActiveModel, QueryFilter, StreamTrait,
     },
-    tap::{Pipe, Tap},
+    tap::Pipe,
 };
 use tracing::{info, instrument};
 
-use super::{
-    ActiveModel, Checked, Column, Entity, OperateResult, VideoOperate,
-};
+use super::{Checked, Column, Entity, OperateResult, VideoOperate};
 
 impl VideoOperate<'_, NoConnect> {
     pub async fn all_soft_remove(
@@ -66,18 +68,12 @@ where
             .map(|(order, video)| {
                 match exist_data.remove(video.bv.as_str()) {
                     Some(model) => {
-                        model.into_active_model().tap_mut(|active| {
-                            active.update_with_video_and_order(
-                                video,
-                                order as i32,
-                            )
-                        })
+                        model
+                            .into_active_model()
+                            .chain_update(video.with(FieldOrder, order as _))
                     }
                     None => {
-                        ActiveModel::from_video_data_with_order(
-                            video,
-                            order as i32,
-                        )
+                        video.with(FieldOrder, order as _).into_active_model()
                     }
                 }
             })

persistence/database/database_traits/src/has_scheme.rs

@@ -0,0 +1,28 @@
+pub trait Has<S: Field> {
+    type Ty;
+
+    fn get(&self) -> Option<&Self::Ty> { None }
+
+    fn set(&mut self, value: Self::Ty);
+
+    fn set_optional(&mut self, value: Option<Self::Ty>) {
+        if let Some(value) = value {
+            self.set(value)
+        }
+    }
+}
+
+pub trait Field {
+    const NAME: &'static str;
+}
+
+#[macro_export]
+macro_rules! has_field {
+    ($name:ident : $field:ident) => {
+        pub struct $name;
+
+        impl $crate::has_scheme::Field for $name {
+            const NAME: &'static str = stringify!($field);
+        }
+    };
+}

persistence/database/database_traits/src/lib.rs

@@ -2,6 +2,7 @@ use std::{future::Future, pin::Pin};
 
 pub mod database_operates;
 pub mod get_connect;
+pub mod has_scheme;
 pub mod initial;
 
 pub type BoxedResultFuture<'r, T, E> =

persistence/database/sql_connection/src/ext_traits/active_updater.rs

@@ -0,0 +1,33 @@
+use sea_orm::ActiveModelTrait;
+
+pub trait ActiveModelUpdater<A: ActiveModelTrait> {
+    fn update_active(self, active_model: &mut A);
+}
+
+impl<A, F> ActiveModelUpdater<A> for F
+where
+    A: ActiveModelTrait,
+    F: FnOnce(&mut A),
+{
+    fn update_active(self, active_model: &mut A) { (self)(active_model) }
+}
+
+pub trait UpdateActiveModel<Updater>
+where
+    Updater: ActiveModelUpdater<Self>,
+    Self: Sized + ActiveModelTrait,
+{
+    fn update(&mut self, updater: Updater) { updater.update_active(self); }
+
+    fn chain_update(mut self, updater: Updater) -> Self {
+        updater.update_active(&mut self);
+        self
+    }
+}
+
+impl<T, A> UpdateActiveModel<A> for T
+where
+    T: ActiveModelTrait + Sized,
+    A: ActiveModelUpdater<T>,
+{
+}

persistence/database/sql_connection/src/ext_traits/counter.rs

@@ -0,0 +1,60 @@
+use sea_orm::{DbErr, FromQueryResult, QueryResult};
+
+use super::COUNT_NAME;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(transparent)]
+pub struct Count(pub u64);
+
+impl Count {
+    pub fn is_empty(&self) -> bool { self == 0u64 }
+}
+
+impl PartialEq<u64> for Count {
+    fn eq(&self, other: &u64) -> bool { &self.0 == other }
+}
+
+impl PartialEq<u64> for &Count {
+    fn eq(&self, other: &u64) -> bool { &self.0 == other }
+}
+
+impl FromQueryResult for Count {
+    fn from_query_result(
+        res: &QueryResult, pre: &str,
+    ) -> Result<Self, DbErr> {
+        let count: i64 = res.try_get(pre, COUNT_NAME)?;
+        Ok(Self(count as u64))
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(transparent)]
+pub struct CountZero(pub bool);
+
+impl CountZero {
+    pub fn take(self) -> bool { self.0 }
+}
+
+impl FromQueryResult for CountZero {
+    fn from_query_result(
+        res: &QueryResult, pre: &str,
+    ) -> Result<Self, DbErr> {
+        Ok(CountZero(Count::from_query_result(res, pre)? == 0))
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(transparent)]
+pub struct CountNonZero(pub bool);
+
+impl FromQueryResult for CountNonZero {
+    fn from_query_result(
+        res: &QueryResult, pre: &str,
+    ) -> Result<Self, DbErr> {
+        Ok(CountNonZero(Count::from_query_result(res, pre)? != 0))
+    }
+}
+
+impl CountNonZero {
+    pub fn take(self) -> bool { self.0 }
+}

persistence/database/sql_connection/src/ext_traits/mod.rs

@@ -1,65 +1,11 @@
-use sea_orm::{DbErr, FromQueryResult, QueryResult};
-
 pub mod active_or_set;
+pub mod active_updater;
 pub mod check_all_exist;
+pub mod counter;
 pub mod select_count;
 pub mod soft_delete;
+pub mod with_field;
 
+pub use active_updater::{ActiveModelUpdater, UpdateActiveModel};
+pub use counter::{Count, CountNonZero, CountZero};
 const COUNT_NAME: &str = "count";
-
-#[derive(Debug, Clone, Copy)]
-#[repr(transparent)]
-pub struct Count(pub u64);
-
-impl Count {
-    pub fn is_empty(&self) -> bool { self == 0u64 }
-}
-
-impl PartialEq<u64> for Count {
-    fn eq(&self, other: &u64) -> bool { &self.0 == other }
-}
-
-impl PartialEq<u64> for &Count {
-    fn eq(&self, other: &u64) -> bool { &self.0 == other }
-}
-
-impl FromQueryResult for Count {
-    fn from_query_result(
-        res: &QueryResult, pre: &str,
-    ) -> Result<Self, DbErr> {
-        let count: i64 = res.try_get(pre, COUNT_NAME)?;
-        Ok(Self(count as u64))
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-#[repr(transparent)]
-pub struct CountZero(pub bool);
-
-impl CountZero {
-    pub fn take(self) -> bool { self.0 }
-}
-
-impl FromQueryResult for CountZero {
-    fn from_query_result(
-        res: &QueryResult, pre: &str,
-    ) -> Result<Self, DbErr> {
-        Ok(CountZero(Count::from_query_result(res, pre)? == 0))
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-#[repr(transparent)]
-pub struct CountNonZero(pub bool);
-
-impl FromQueryResult for CountNonZero {
-    fn from_query_result(
-        res: &QueryResult, pre: &str,
-    ) -> Result<Self, DbErr> {
-        Ok(CountNonZero(Count::from_query_result(res, pre)? != 0))
-    }
-}
-
-impl CountNonZero {
-    pub fn take(self) -> bool { self.0 }
-}

persistence/database/sql_connection/src/ext_traits/with_field.rs

@@ -0,0 +1,49 @@
+use database_traits::{
+    has_field,
+    has_scheme::{Field, Has},
+};
+use sea_orm::{ActiveModelTrait, IntoActiveModel};
+
+use crate::ext_traits::ActiveModelUpdater;
+
+pub struct WithField<F: Field, A: Has<F>, T>(pub A::Ty, pub T);
+
+impl<F, A, T> IntoActiveModel<A> for WithField<F, A, T>
+where
+    F: Field,
+    A: Has<F> + ActiveModelTrait,
+    T: IntoActiveModel<A>,
+{
+    fn into_active_model(self) -> A {
+        let mut this = self.1.into_active_model();
+        Has::set(&mut this, self.0);
+        this
+    }
+}
+
+impl<F, A, T> ActiveModelUpdater<A> for WithField<F, A, T>
+where
+    A: ActiveModelTrait + Has<F>,
+    T: ActiveModelUpdater<A>,
+    F: Field,
+{
+    fn update_active(self, active_model: &mut A) {
+        Has::<F>::set(active_model, self.0);
+        self.1.update_active(active_model);
+    }
+}
+
+pub trait With<A>: Sized {
+    fn with<F>(self, _: F, field: A::Ty) -> WithField<F, A, Self>
+    where
+        F: Field,
+        A: Has<F>,
+    {
+        WithField(field, self)
+    }
+}
+
+impl<T: Sized, A> With<A> for T {}
+
+has_field!(FieldOrder:order);
+pub type UpdateWithOrder<A, T> = WithField<FieldOrder, A, T>;

persistence/migrate/sql-migration/src/ceobe_operation_desktop_version/m20230729_211229_create.rs

@@ -1,4 +1,7 @@
-use sea_orm_migration::{prelude::*, sea_orm::Statement};
+use sea_orm_migration::{
+    prelude::*,
+    sea_orm::{ConnectionTrait, Statement},
+};
 
 pub struct Migration;
 impl MigrationName for Migration {

persistence/models/sql-models/src/ceobe_operation/announcement/checkers/announcement_data.rs

@@ -6,11 +6,11 @@ use checker::{
     },
 };
 use chrono::NaiveDateTime;
-use sea_orm::Set;
+use sea_orm::{IntoActiveModel, Set};
 use typed_builder::TypedBuilder;
 
 use super::CheckError;
-use crate::ceobe_operation::announcement::models::model_announcement;
+use crate::ceobe_operation::announcement::ActiveModel;
 
 #[derive(Debug, TypedBuilder)]
 pub struct CeobeOpAnnouncement {
@@ -34,23 +34,20 @@ pub struct CeobeOpAnnouncementChecker {
     pub notice: NoCheck<bool>,
 }
 
-impl model_announcement::ActiveModel {
-    pub fn from_announcement_data_with_order(
-        CeobeOpAnnouncement {
+impl IntoActiveModel<ActiveModel> for CeobeOpAnnouncement {
+    fn into_active_model(self) -> ActiveModel {
+        let Self {
             start_time,
             over_time,
             content,
             img_url,
             notice,
-        }: CeobeOpAnnouncement,
-        order: i32,
-    ) -> Self {
-        Self {
+        } = self;
+        ActiveModel {
             start_time: Set(start_time),
             over_time: Set(over_time),
             content: Set(content),
             img_url: Set(img_url),
-            order: Set(order),
             notice: Set(notice),
             ..Default::default()
         }

persistence/models/sql-models/src/ceobe_operation/announcement/models/model_announcement.rs

@@ -1,4 +1,7 @@
-use sea_orm::{entity::prelude::*, ActiveValue};
+use sea_orm::{entity::prelude::*, ActiveValue, ActiveValue::Set};
+use sql_connection::{
+    database_traits::has_scheme::Has, ext_traits::with_field::FieldOrder,
+};
 
 use crate::{NaiveDateTime, SoftDelete};
 
@@ -31,3 +34,9 @@ impl SoftDelete for ActiveModel {
         &mut self.delete_at
     }
 }
+
+impl Has<FieldOrder> for ActiveModel {
+    type Ty = i32;
+
+    fn set(&mut self, value: Self::Ty) { self.order = Set(value); }
+}