netcore 基于orm查询的条件拼接

netcore 基于orm查询的条件拼接。

帮助类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Insurance.Api.Model.Models.Labour;

namespace Insurance.Application.Helpers
{
    /// <summary>
    /// LabourRecord 查询辅助类
    /// 用于处理 JsonResult 中的数据查询和日期比较
    /// </summary>
    public static class LabourRecordQueryHelper
    {
        /// <summary>
        /// 查询条件委托
        /// </summary>
        public delegate bool QueryCondition(Dictionary<string, string> jsonData);

        /// <summary>
        /// 创建简单的相等条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="value">值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateEqualCondition(string fieldName, string value)
        {
            return (jsonData) => jsonData.GetFieldValue(fieldName) == value;
        }

        /// <summary>
        /// 创建简单的相等条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="value">值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateNotEqualCondition(string fieldName, string value)
        {
            return (jsonData) => jsonData.GetFieldValue(fieldName) != value;
        }

        /// <summary>
        /// 创建日期大于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateGreaterThanCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateGreaterThan(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期小于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateLessThanCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateLessThan(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期等于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateEqualCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateEqual(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期大于等于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateGreaterThanOrEqualCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateGreaterThanOrEqual(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期小于等于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateLessThanOrEqualCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateLessThanOrEqual(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建字段 IndexOf 条件
        /// 如：P11.IndexOf("12") > -1 表示 P11 包含 "12"
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="searchValue">要查找的值</param>
        /// <param name="compareValue">比较值（通常是 -1 用于检查是否包含）</param>
        /// <param name="comparison">比较类型：>, <, ==, !=, >=, <=</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateIndexOfCondition(
            string fieldName,
            string searchValue,
            int compareValue,
            string comparison = ">")
        {
            return (jsonData) =>
            {
                var fieldValue = jsonData.GetFieldValue(fieldName);
                if (string.IsNullOrEmpty(fieldValue))
                {
                    return false;
                }

                var indexOfResult = fieldValue.IndexOf(searchValue, StringComparison.Ordinal);

                return comparison switch
                {
                    ">" => indexOfResult > compareValue,
                    "<" => indexOfResult < compareValue,
                    "==" => indexOfResult == compareValue,
                    "!=" => indexOfResult != compareValue,
                    ">=" => indexOfResult >= compareValue,
                    "<=" => indexOfResult <= compareValue,
                    _ => throw new ArgumentException($"不支持的比较类型: {comparison}")
                };
            };
        }

        /// <summary>
        /// 创建字段包含检查条件（简化的 IndexOf > -1）
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="searchValue">要查找的值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateContainsCondition(string fieldName, string searchValue)
        {
            return CreateIndexOfCondition(fieldName, searchValue, -1, ">");
        }

        /// <summary>
        /// 创建常量字符串 IndexOf 条件
        /// 如："12".IndexOf(S15) > -1 表示 "12" 包含 S15 的值
        /// </summary>
        /// <param name="constantString">常量字符串</param>
        /// <param name="fieldName">字段名</param>
        /// <param name="compareValue">比较值（通常是 -1 用于检查是否包含）</param>
        /// <param name="comparison">比较类型：>, <, ==, !=, >=, <=</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateConstantIndexOfCondition(
            string constantString,
            string fieldName,
            int compareValue,
            string comparison = ">")
        {
            return (jsonData) =>
            {
                var fieldValue = jsonData.GetFieldValue(fieldName);
                if (string.IsNullOrEmpty(fieldValue))
                {
                    return false;
                }

                var indexOfResult = constantString.IndexOf(fieldValue, StringComparison.Ordinal);

                return comparison switch
                {
                    ">" => indexOfResult > compareValue,
                    "<" => indexOfResult < compareValue,
                    "==" => indexOfResult == compareValue,
                    "!=" => indexOfResult != compareValue,
                    ">=" => indexOfResult >= compareValue,
                    "<=" => indexOfResult <= compareValue,
                    _ => throw new ArgumentException($"不支持的比较类型: {comparison}")
                };
            };
        }

        /// <summary>
        /// 创建常量字符串包含字段值检查条件（简化的常量 IndexOf > -1）
        /// </summary>
        /// <param name="constantString">常量字符串</param>
        /// <param name="fieldName">字段名</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateConstantContainsCondition(string constantString, string fieldName)
        {
            return CreateConstantIndexOfCondition(constantString, fieldName, -1, ">");
        }

        /// <summary>
        /// 创建字段 SubString 条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="start">起始位置</param>
        /// <param name="length">长度</param>
        /// <param name="compareValue">比较值</param>
        /// <param name="comparison">比较类型：==, !=</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateSubStringCondition(
            string fieldName,
            int start,
            int length,
            string compareValue,
            string comparison = "==")
        {
            return (jsonData) =>
            {
                var fieldValue = jsonData.GetFieldValue(fieldName);
                if (string.IsNullOrEmpty(fieldValue) || fieldValue.Length < start + length)
                {
                    return false;
                }

                var subString = fieldValue.Substring(start, length);

                return comparison switch
                {
                    "==" => subString == compareValue,
                    "!=" => subString != compareValue,
                    _ => throw new ArgumentException($"SubString 只支持 == 或 != 比较")
                };
            };
        }

        /// <summary>
        /// 组合多个条件（AND）
        /// </summary>
        /// <param name="conditions">条件数组</param>
        /// <returns>组合后的查询条件</returns>
        public static QueryCondition CombineAnd(params QueryCondition[] conditions)
        {
            return (jsonData) => conditions.All(condition => condition(jsonData));
        }

        /// <summary>
        /// 组合多个条件（OR）
        /// </summary>
        /// <param name="conditions">条件数组</param>
        /// <returns>组合后的查询条件</returns>
        public static QueryCondition CombineOr(params QueryCondition[] conditions)
        {
            return (jsonData) => conditions.Any(condition => condition(jsonData));
        }
    }
}

调用方法

见分进元

public LabourRecordQueryHelper.QueryCondition GetQueryCondition(
        string startDate,
        string endDate)
    {
        // 实现你的查询条件逻辑
        var condition1 = LabourRecordQueryHelper.CreateEqualCondition("S15", "1");
        var condition2 = LabourRecordQueryHelper.CreateSubStringCondition("P11", 0, 2, "00", "!=");
        var conditionResult1 = LabourRecordQueryHelper.CombineAnd(condition1, condition2);

        LabourRecordQueryHelper.QueryCondition condition3 = LabourRecordQueryHelper.CreateNotEqualCondition("G62", "是");
        LabourRecordQueryHelper.QueryCondition condition4 = LabourRecordQueryHelper.CreateNotEqualCondition("G62", "T");
        var conditionResult2 = LabourRecordQueryHelper.CombineAnd(condition3, condition4);

        return LabourRecordQueryHelper.CombineAnd(conditionResult1, conditionResult2);
    }