feat: add in condition

Author: DataEraserC

file_classification_core/src/internal/file_group.rs

@@ -44,6 +44,9 @@ fn build_file_group_condition(condition: FileGroupCondition) -> Box<dyn BoxableE
         FileGroupCondition::GroupIdGreaterThan(value) => Box::new(file_groups::group_id.gt(value)),
         FileGroupCondition::GroupIdLessThan(value) => Box::new(file_groups::group_id.lt(value)),
 
+        FileGroupCondition::FileIdIn(values) => Box::new(file_groups::file_id.eq_any(values)),
+        FileGroupCondition::GroupIdIn(values) => Box::new(file_groups::group_id.eq_any(values)),
+
         FileGroupCondition::And(conditions) => {
             let mut result: Option<Box<dyn BoxableExpression<file_groups::table, <AnyConnection as Connection>::Backend, SqlType=diesel::sql_types::Bool>>> = None;
             for cond in conditions {

file_classification_core/src/internal/files.rs

@@ -104,6 +104,12 @@ fn build_file_condition(condition: FileCondition) -> Box<dyn BoxableExpression<f
         FileCondition::ReferenceCountLessThan(value) => Box::new(files::reference_count.lt(value)),
         FileCondition::GroupIdGreaterThan(value) => Box::new(files::group_id.gt(value)),
         FileCondition::GroupIdLessThan(value) => Box::new(files::group_id.lt(value)),
+        
+        FileCondition::IdIn(values) => Box::new(files::id.eq_any(values)),
+        FileCondition::TypeIn(values) => Box::new(files::type_.eq_any(values)),
+        FileCondition::PathIn(values) => Box::new(files::path.eq_any(values)),
+        FileCondition::ReferenceCountIn(values) => Box::new(files::reference_count.eq_any(values)),
+        FileCondition::GroupIdIn(values) => Box::new(files::group_id.eq_any(values)),
 
         FileCondition::And(conditions) => {
             let mut result: Option<Box<dyn BoxableExpression<files::table, <AnyConnection as Connection>::Backend, SqlType=diesel::sql_types::Bool>>> = None;

file_classification_core/src/internal/group_tag.rs

@@ -47,6 +47,9 @@ fn build_group_tag_condition(condition: GroupTagCondition) -> Box<dyn BoxableExp
         GroupTagCondition::GroupIdLessThan(value) => Box::new(group_tags::group_id.lt(value)),
         GroupTagCondition::TagIdGreaterThan(value) => Box::new(group_tags::tag_id.gt(value)),
         GroupTagCondition::TagIdLessThan(value) => Box::new(group_tags::tag_id.lt(value)),
+        
+        GroupTagCondition::GroupIdIn(values) => Box::new(group_tags::group_id.eq_any(values)),
+        GroupTagCondition::TagIdIn(values) => Box::new(group_tags::tag_id.eq_any(values)),
 
         GroupTagCondition::And(conditions) => {
             let mut result: Option<Box<dyn BoxableExpression<group_tags::table, <AnyConnection as Connection>::Backend, SqlType=diesel::sql_types::Bool>>> = None;

file_classification_core/src/internal/groups.rs

@@ -152,6 +152,14 @@ fn build_group_condition(condition: GroupCondition) -> Box<dyn BoxableExpression
         GroupCondition::CreateTimeLessThan(time) => Box::new(groups::create_time.lt(time)),
         GroupCondition::ModifyTimeGreaterThan(time) => Box::new(groups::modify_time.gt(time)),
         GroupCondition::ModifyTimeLessThan(time) => Box::new(groups::modify_time.lt(time)),
+        
+        GroupCondition::IdIn(values) => Box::new(groups::id.eq_any(values)),
+        GroupCondition::NameIn(values) => Box::new(groups::name.eq_any(values)),
+        GroupCondition::ReferenceCountIn(values) => Box::new(groups::reference_count.eq_any(values)),
+        GroupCondition::ClickCountIn(values) => Box::new(groups::click_count.eq_any(values)),
+        GroupCondition::ShareCountIn(values) => Box::new(groups::share_count.eq_any(values)),
+        GroupCondition::CreateTimeIn(values) => Box::new(groups::create_time.eq_any(values)),
+        GroupCondition::ModifyTimeIn(values) => Box::new(groups::modify_time.eq_any(values)),
 
         GroupCondition::And(conditions) => {
             let mut result: Option<Box<dyn BoxableExpression<groups::table, <AnyConnection as Connection>::Backend, SqlType=diesel::sql_types::Bool>>> = None;

file_classification_core/src/internal/tags.rs

@@ -110,6 +110,10 @@ fn build_tag_condition(condition: TagCondition) -> Box<dyn BoxableExpression<tag
         TagCondition::ReferenceCountGreaterThan(value) => Box::new(tags::reference_count.gt(value)),
         TagCondition::ReferenceCountLessThan(value) => Box::new(tags::reference_count.lt(value)),
 
+        TagCondition::IdIn(values) => Box::new(tags::id.eq_any(values)),
+        TagCondition::NameIn(values) => Box::new(tags::name.eq_any(values)),
+        TagCondition::ReferenceCountIn(values) => Box::new(tags::reference_count.eq_any(values)),
+
         TagCondition::And(conditions) => {
             let mut result: Option<Box<dyn BoxableExpression<tags::table, <AnyConnection as Connection>::Backend, SqlType=diesel::sql_types::Bool>>> = None;
             for cond in conditions {

file_classification_core/src/model/models.rs

@@ -54,6 +54,12 @@ pub enum FileCondition {
     GroupIdGreaterThan(i32),
     GroupIdLessThan(i32),
 
+    IdIn(Vec<i32>),
+    TypeIn(Vec<String>),
+    PathIn(Vec<String>),
+    ReferenceCountIn(Vec<i32>),
+    GroupIdIn(Vec<i32>),
+
     And(Vec<FileCondition>),
     Or(Vec<FileCondition>),
     Not(Box<FileCondition>),
@@ -131,6 +137,14 @@ pub enum GroupCondition {
     ModifyTimeGreaterThan(chrono::NaiveDateTime),
     ModifyTimeLessThan(chrono::NaiveDateTime),
 
+    IdIn(Vec<i32>),
+    NameIn(Vec<String>),
+    ReferenceCountIn(Vec<i32>),
+    ClickCountIn(Vec<i32>),
+    ShareCountIn(Vec<i32>),
+    CreateTimeIn(Vec<chrono::NaiveDateTime>),
+    ModifyTimeIn(Vec<chrono::NaiveDateTime>),
+
     And(Vec<GroupCondition>),
     Or(Vec<GroupCondition>),
     Not(Box<GroupCondition>),
@@ -231,6 +245,10 @@ pub enum TagCondition {
     ReferenceCountGreaterThan(i32),
     ReferenceCountLessThan(i32),
 
+    IdIn(Vec<i32>),
+    NameIn(Vec<String>),
+    ReferenceCountIn(Vec<i32>),
+
     And(Vec<TagCondition>),
     Or(Vec<TagCondition>),
     Not(Box<TagCondition>),
@@ -294,6 +312,9 @@ pub enum FileGroupCondition {
     GroupIdGreaterThan(i32),
     GroupIdLessThan(i32),
 
+    FileIdIn(Vec<i32>),
+    GroupIdIn(Vec<i32>),
+
     And(Vec<FileGroupCondition>),
     Or(Vec<FileGroupCondition>),
     Not(Box<FileGroupCondition>),
@@ -332,6 +353,9 @@ pub enum GroupTagCondition {
     TagIdGreaterThan(i32),
     TagIdLessThan(i32),
 
+    GroupIdIn(Vec<i32>),
+    TagIdIn(Vec<i32>),
+
     And(Vec<GroupTagCondition>),
     Or(Vec<GroupTagCondition>),
     Not(Box<GroupTagCondition>),