<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.perform.dao.ibatis.PerformAttendAppealDaoImpl">

    <!-- 申述分布情况统计 -->
    <select id="getAppealSummaryList" parameterType="com.mortals.xhx.module.perform.model.vo.AppealSummaryQuery" resultType="com.mortals.xhx.module.perform.model.PerformAttendAppealEntity">
        SELECT
            performType,
            SUM(score) AS score
        FROM
            mortals_xhx_perform_attend_appeal
        WHERE
            processStatus = 2
        AND appealResult = 1
        <if test="checkTimeStart != null and checkTimeStart!=''"> AND checkTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{checkTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') </if>
        <if test="checkTimeEnd != null and checkTimeEnd!=''"> AND checkTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{checkTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') </if>
        GROUP BY
            performType
    </select>

    <resultMap type="PerformAttendAppealEntity" id="PerformAttendAppealEntity-MapExt">
        <id  property="id" column="id" />
        <result property="checkRecordId" column="checkRecordId" />
        <result property="staffId" column="staffId" />
        <result property="staffName" column="staffName" />
        <result property="workNum" column="workNum" />
        <result property="deptId" column="deptId" />
        <result property="deptName" column="deptName" />
        <result property="attendanceGroupId" column="attendanceGroupId" />
        <result property="attendanceGroupName" column="attendanceGroupName" />
        <result property="attendanceDate" column="attendanceDate" />
        <result property="violationType" column="violationType" />
        <result property="ruleId" column="ruleId" />
        <result property="ruleName" column="ruleName" />
        <result property="subMethod" column="subMethod" />
        <result property="deductPerson" column="deductPerson" />
        <result property="deductTime" column="deductTime" />
        <result property="subAddType" column="subAddType" />
        <result property="score" column="score" />
        <result property="goOffTimeStr" column="goOffTimeStr" />
        <result property="errorTime" column="errorTime" />
        <result property="actualAttendTime" column="actualAttendTime" />
        <result property="errorResult" column="errorResult" />
        <result property="checkPerson" column="checkPerson" />
        <result property="checkTime" column="checkTime" />
        <result property="checkDesc" column="checkDesc" />
        <result property="checkResult" column="checkResult" />
        <result property="processStatus" column="processStatus" />
        <result property="appealDesc" column="appealDesc" />
        <result property="appealTime" column="appealTime" />
        <result property="appealResult" column="appealResult" />
        <result property="remark" column="remark" />
        <result property="reviewResult" column="reviewResult" />
        <result property="reviewTime" column="reviewTime" />
        <result property="reviewSource" column="reviewSource" />
        <result property="reviewDevice" column="reviewDevice" />
        <result property="complainTitle" column="complainTitle" />
        <result property="complainContent" column="complainContent" />
        <result property="complainRealName" column="complainRealName" />
        <result property="contact" column="contact" />
        <result property="complainTime" column="complainTime" />
        <result property="complainSource" column="complainSource" />
        <result property="complainDevice" column="complainDevice" />
        <result property="goworkCode" column="goworkCode" />
        <result property="goworkDepts" column="goworkDepts" />
        <result property="matterlName" column="matterlName" />
        <result property="goworkTime" column="goworkTime" />
        <result property="irregularType" column="irregularType" />
        <result property="happenTime" column="happenTime" />
        <result property="duration" column="duration" />
        <result property="alarmTime" column="alarmTime" />
        <result property="snapPath" column="snapPath" />
        <result property="irregularOtherType" column="irregularOtherType" />
        <result property="performType" column="performType" />
        <result property="windowNum" column="windowNum" />
        <result property="createUserId" column="createUserId" />
        <result property="createTime" column="createTime" />
        <result property="updateUserId" column="updateUserId" />
        <result property="updateTime" column="updateTime" />
        <result property="salaId" column="salaId" />
        <result property="salaName" column="salaName" />
        <result property="appealPersonId" column="appealPersonId" />
        <result property="appealPerson" column="appealPerson" />
        <result property="processTime" column="processTime" />
        <result property="processPerson" column="processPerson" />
        <result property="checkStatus" column="checkStatus" />
    </resultMap>
    <!-- 获取列表 -->
    <select id="getListExt" parameterType="paramDto" resultMap="PerformAttendAppealEntity-MapExt">
        SELECT a.* FROM (
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_attend_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='attend'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_complain_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='complain'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_effect_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='effect'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_gowork_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='gowork'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_other_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='other'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_review_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='review'
        ) as a
        <trim suffixOverrides="where" suffix="">
            where
            <trim prefixOverrides="and" prefix="">
                <include refid="_condition_ext_"/>
            </trim>
        </trim>
        <include refid="_orderCols_"/>
    </select>
    <!-- 获取 -->
    <select id="getListCountExt" parameterType="paramDto" resultType="int">
        select count(1)
        from
        (
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_attend_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='attend'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_complain_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='complain'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_effect_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='effect'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_gowork_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='gowork'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_other_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='other'
        UNION
        SELECT t1.*,t2.checkStatus FROM mortals_xhx_perform_attend_appeal t1,mortals_xhx_check_review_record t2 WHERE t1.checkRecordId=t2.id AND t1.performType='review'
        ) as a
        <trim suffixOverrides="where" suffix="">
            where
            <trim prefixOverrides="and" prefix="">
                <include refid="_condition_ext_"/>
            </trim>
        </trim>
    </select>
    <!-- 条件映射 -->
    <sql id="_condition_ext_">
        <if test="condition != null and !condition.isEmpty()">
            <!-- 条件映射-普通条件 -->
            <include refid="_condition_param_ext_">
                <property name="_conditionParam_" value="condition"/>
                <property name="_conditionType_" value="and"/>
            </include>
            <!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
            <if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
                and
                <foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
                    <trim prefixOverrides="or" prefix="(" suffix=")">
                        <include refid="_condition_param_ext_">
                            <property name="_conditionParam_" value="andCondition"/>
                            <property name="_conditionType_" value="or"/>
                        </include>
                    </trim>
                </foreach>
            </if>
            <!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
            <if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
                and
                <foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
                    <trim prefixOverrides="and" prefix="(" suffix=")">
                        <include refid="_condition_param_">
                            <property name="_conditionParam_" value="orCondition"/>
                            <property name="_conditionType_" value="and"/>
                        </include>
                    </trim>
                </foreach>
            </if>
        </if>
    </sql>
    <!-- 条件映射-代参数 -->
    <sql id="_condition_param_ext_">
        <bind name="conditionParamRef" value="${_conditionParam_}"/>
        <if test="conditionParamRef.containsKey('id')">
            <if test="conditionParamRef.id != null">
                ${_conditionType_} a.id=#{${_conditionParam_}.id}
            </if>
        </if>
        <if test="conditionParamRef.containsKey('id')">
            <if test="conditionParamRef.id != null ">
                ${_conditionType_} a.id = #{${_conditionParam_}.id}
            </if>
            <if test="conditionParamRef.id == null">
                ${_conditionType_} a.id is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
            ${_conditionType_} a.id in
            <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
            ${_conditionType_} a.id not in
            <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
            ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
        </if>
        <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
            ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
        </if>

        <if test="conditionParamRef.containsKey('checkRecordId')">
            <if test="conditionParamRef.checkRecordId != null ">
                ${_conditionType_} a.checkRecordId = #{${_conditionParam_}.checkRecordId}
            </if>
            <if test="conditionParamRef.checkRecordId == null">
                ${_conditionType_} a.checkRecordId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('checkRecordIdList') and conditionParamRef.checkRecordIdList.size() > 0">
            ${_conditionType_} a.checkRecordId in
            <foreach collection="conditionParamRef.checkRecordIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('checkRecordIdNotList') and conditionParamRef.checkRecordIdNotList.size() > 0">
            ${_conditionType_} a.checkRecordId not in
            <foreach collection="conditionParamRef.checkRecordIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('checkRecordIdStart') and conditionParamRef.checkRecordIdStart != null">
            ${_conditionType_} a.checkRecordId <![CDATA[ >= ]]> #{${_conditionParam_}.checkRecordIdStart}
        </if>
        <if test="conditionParamRef.containsKey('checkRecordIdEnd') and conditionParamRef.checkRecordIdEnd != null">
            ${_conditionType_} a.checkRecordId <![CDATA[ <= ]]> #{${_conditionParam_}.checkRecordIdEnd}
        </if>

        <if test="conditionParamRef.containsKey('staffId')">
            <if test="conditionParamRef.staffId != null ">
                ${_conditionType_} a.staffId = #{${_conditionParam_}.staffId}
            </if>
            <if test="conditionParamRef.staffId == null">
                ${_conditionType_} a.staffId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('staffIdList') and conditionParamRef.staffIdList.size() > 0">
            ${_conditionType_} a.staffId in
            <foreach collection="conditionParamRef.staffIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('staffIdNotList') and conditionParamRef.staffIdNotList.size() > 0">
            ${_conditionType_} a.staffId not in
            <foreach collection="conditionParamRef.staffIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('staffIdStart') and conditionParamRef.staffIdStart != null">
            ${_conditionType_} a.staffId <![CDATA[ >= ]]> #{${_conditionParam_}.staffIdStart}
        </if>
        <if test="conditionParamRef.containsKey('staffIdEnd') and conditionParamRef.staffIdEnd != null">
            ${_conditionType_} a.staffId <![CDATA[ <= ]]> #{${_conditionParam_}.staffIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('staffName')">
            <if test="conditionParamRef.staffName != null and conditionParamRef.staffName != ''">
                ${_conditionType_} a.staffName like #{${_conditionParam_}.staffName}
            </if>
            <if test="conditionParamRef.staffName == null">
                ${_conditionType_} a.staffName is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('staffNameList') and conditionParamRef.staffNameList.size() > 0">
            ${_conditionType_} a.staffName in
            <foreach collection="conditionParamRef.staffNameList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('staffNameNotList') and conditionParamRef.staffNameNotList.size() > 0">
            ${_conditionType_} a.staffName not in
            <foreach collection="conditionParamRef.staffNameNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('workNum')">
            <if test="conditionParamRef.workNum != null and conditionParamRef.workNum != ''">
                ${_conditionType_} a.workNum like #{${_conditionParam_}.workNum}
            </if>
            <if test="conditionParamRef.workNum == null">
                ${_conditionType_} a.workNum is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('workNumList') and conditionParamRef.workNumList.size() > 0">
            ${_conditionType_} a.workNum in
            <foreach collection="conditionParamRef.workNumList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('workNumNotList') and conditionParamRef.workNumNotList.size() > 0">
            ${_conditionType_} a.workNum not in
            <foreach collection="conditionParamRef.workNumNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('deptId')">
            <if test="conditionParamRef.deptId != null ">
                ${_conditionType_} a.deptId = #{${_conditionParam_}.deptId}
            </if>
            <if test="conditionParamRef.deptId == null">
                ${_conditionType_} a.deptId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('deptIdList') and conditionParamRef.deptIdList.size() > 0">
            ${_conditionType_} a.deptId in
            <foreach collection="conditionParamRef.deptIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('deptIdNotList') and conditionParamRef.deptIdNotList.size() > 0">
            ${_conditionType_} a.deptId not in
            <foreach collection="conditionParamRef.deptIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('deptIdStart') and conditionParamRef.deptIdStart != null">
            ${_conditionType_} a.deptId <![CDATA[ >= ]]> #{${_conditionParam_}.deptIdStart}
        </if>
        <if test="conditionParamRef.containsKey('deptIdEnd') and conditionParamRef.deptIdEnd != null">
            ${_conditionType_} a.deptId <![CDATA[ <= ]]> #{${_conditionParam_}.deptIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('deptName')">
            <if test="conditionParamRef.deptName != null and conditionParamRef.deptName != ''">
                ${_conditionType_} a.deptName like #{${_conditionParam_}.deptName}
            </if>
            <if test="conditionParamRef.deptName == null">
                ${_conditionType_} a.deptName is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('deptNameList') and conditionParamRef.deptNameList.size() > 0">
            ${_conditionType_} a.deptName in
            <foreach collection="conditionParamRef.deptNameList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('deptNameNotList') and conditionParamRef.deptNameNotList.size() > 0">
            ${_conditionType_} a.deptName not in
            <foreach collection="conditionParamRef.deptNameNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('attendanceGroupId')">
            <if test="conditionParamRef.attendanceGroupId != null ">
                ${_conditionType_} a.attendanceGroupId = #{${_conditionParam_}.attendanceGroupId}
            </if>
            <if test="conditionParamRef.attendanceGroupId == null">
                ${_conditionType_} a.attendanceGroupId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('attendanceGroupIdList') and conditionParamRef.attendanceGroupIdList.size() > 0">
            ${_conditionType_} a.attendanceGroupId in
            <foreach collection="conditionParamRef.attendanceGroupIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('attendanceGroupIdNotList') and conditionParamRef.attendanceGroupIdNotList.size() > 0">
            ${_conditionType_} a.attendanceGroupId not in
            <foreach collection="conditionParamRef.attendanceGroupIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('attendanceGroupIdStart') and conditionParamRef.attendanceGroupIdStart != null">
            ${_conditionType_} a.attendanceGroupId <![CDATA[ >= ]]> #{${_conditionParam_}.attendanceGroupIdStart}
        </if>
        <if test="conditionParamRef.containsKey('attendanceGroupIdEnd') and conditionParamRef.attendanceGroupIdEnd != null">
            ${_conditionType_} a.attendanceGroupId <![CDATA[ <= ]]> #{${_conditionParam_}.attendanceGroupIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('attendanceGroupName')">
            <if test="conditionParamRef.attendanceGroupName != null and conditionParamRef.attendanceGroupName != ''">
                ${_conditionType_} a.attendanceGroupName like #{${_conditionParam_}.attendanceGroupName}
            </if>
            <if test="conditionParamRef.attendanceGroupName == null">
                ${_conditionType_} a.attendanceGroupName is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('attendanceGroupNameList') and conditionParamRef.attendanceGroupNameList.size() > 0">
            ${_conditionType_} a.attendanceGroupName in
            <foreach collection="conditionParamRef.attendanceGroupNameList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('attendanceGroupNameNotList') and conditionParamRef.attendanceGroupNameNotList.size() > 0">
            ${_conditionType_} a.attendanceGroupName not in
            <foreach collection="conditionParamRef.attendanceGroupNameNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('attendanceDate')">
            <if test="conditionParamRef.attendanceDate != null ">
                ${_conditionType_} a.attendanceDate = #{${_conditionParam_}.attendanceDate}
            </if>
            <if test="conditionParamRef.attendanceDate == null">
                ${_conditionType_} a.attendanceDate is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('attendanceDateStart') and conditionParamRef.attendanceDateStart != null and conditionParamRef.attendanceDateStart!=''">
            ${_conditionType_} a.attendanceDate <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.attendanceDateStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('attendanceDateEnd') and conditionParamRef.attendanceDateEnd != null and conditionParamRef.attendanceDateEnd!=''">
            ${_conditionType_} a.attendanceDate <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.attendanceDateEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('violationType')">
            <if test="conditionParamRef.violationType != null and conditionParamRef.violationType != ''">
                ${_conditionType_} a.violationType like #{${_conditionParam_}.violationType}
            </if>
            <if test="conditionParamRef.violationType == null">
                ${_conditionType_} a.violationType is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('violationTypeList') and conditionParamRef.violationTypeList.size() > 0">
            ${_conditionType_} a.violationType in
            <foreach collection="conditionParamRef.violationTypeList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('violationTypeNotList') and conditionParamRef.violationTypeNotList.size() > 0">
            ${_conditionType_} a.violationType not in
            <foreach collection="conditionParamRef.violationTypeNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('ruleId')">
            <if test="conditionParamRef.ruleId != null ">
                ${_conditionType_} a.ruleId = #{${_conditionParam_}.ruleId}
            </if>
            <if test="conditionParamRef.ruleId == null">
                ${_conditionType_} a.ruleId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('ruleIdList') and conditionParamRef.ruleIdList.size() > 0">
            ${_conditionType_} a.ruleId in
            <foreach collection="conditionParamRef.ruleIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('ruleIdNotList') and conditionParamRef.ruleIdNotList.size() > 0">
            ${_conditionType_} a.ruleId not in
            <foreach collection="conditionParamRef.ruleIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('ruleIdStart') and conditionParamRef.ruleIdStart != null">
            ${_conditionType_} a.ruleId <![CDATA[ >= ]]> #{${_conditionParam_}.ruleIdStart}
        </if>
        <if test="conditionParamRef.containsKey('ruleIdEnd') and conditionParamRef.ruleIdEnd != null">
            ${_conditionType_} a.ruleId <![CDATA[ <= ]]> #{${_conditionParam_}.ruleIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('ruleName')">
            <if test="conditionParamRef.ruleName != null and conditionParamRef.ruleName != ''">
                ${_conditionType_} a.ruleName like #{${_conditionParam_}.ruleName}
            </if>
            <if test="conditionParamRef.ruleName == null">
                ${_conditionType_} a.ruleName is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('ruleNameList') and conditionParamRef.ruleNameList.size() > 0">
            ${_conditionType_} a.ruleName in
            <foreach collection="conditionParamRef.ruleNameList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('ruleNameNotList') and conditionParamRef.ruleNameNotList.size() > 0">
            ${_conditionType_} a.ruleName not in
            <foreach collection="conditionParamRef.ruleNameNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('subMethod')">
            <if test="conditionParamRef.subMethod != null ">
                ${_conditionType_} a.subMethod = #{${_conditionParam_}.subMethod}
            </if>
            <if test="conditionParamRef.subMethod == null">
                ${_conditionType_} a.subMethod is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('subMethodList') and conditionParamRef.subMethodList.size() > 0">
            ${_conditionType_} a.subMethod in
            <foreach collection="conditionParamRef.subMethodList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('subMethodNotList') and conditionParamRef.subMethodNotList.size() > 0">
            ${_conditionType_} a.subMethod not in
            <foreach collection="conditionParamRef.subMethodNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('subMethodStart') and conditionParamRef.subMethodStart != null">
            ${_conditionType_} a.subMethod <![CDATA[ >= ]]> #{${_conditionParam_}.subMethodStart}
        </if>
        <if test="conditionParamRef.containsKey('subMethodEnd') and conditionParamRef.subMethodEnd != null">
            ${_conditionType_} a.subMethod <![CDATA[ <= ]]> #{${_conditionParam_}.subMethodEnd}
        </if>


        <if test="conditionParamRef.containsKey('deductPerson')">
            <if test="conditionParamRef.deductPerson != null and conditionParamRef.deductPerson != ''">
                ${_conditionType_} a.deductPerson like #{${_conditionParam_}.deductPerson}
            </if>
            <if test="conditionParamRef.deductPerson == null">
                ${_conditionType_} a.deductPerson is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('deductPersonList') and conditionParamRef.deductPersonList.size() > 0">
            ${_conditionType_} a.deductPerson in
            <foreach collection="conditionParamRef.deductPersonList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('deductPersonNotList') and conditionParamRef.deductPersonNotList.size() > 0">
            ${_conditionType_} a.deductPerson not in
            <foreach collection="conditionParamRef.deductPersonNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('deductTime')">
            <if test="conditionParamRef.deductTime != null ">
                ${_conditionType_} a.deductTime = #{${_conditionParam_}.deductTime}
            </if>
            <if test="conditionParamRef.deductTime == null">
                ${_conditionType_} a.deductTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('deductTimeStart') and conditionParamRef.deductTimeStart != null and conditionParamRef.deductTimeStart!=''">
            ${_conditionType_} a.deductTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.deductTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('deductTimeEnd') and conditionParamRef.deductTimeEnd != null and conditionParamRef.deductTimeEnd!=''">
            ${_conditionType_} a.deductTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.deductTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('subAddType')">
            <if test="conditionParamRef.subAddType != null ">
                ${_conditionType_} a.subAddType = #{${_conditionParam_}.subAddType}
            </if>
            <if test="conditionParamRef.subAddType == null">
                ${_conditionType_} a.subAddType is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('subAddTypeList') and conditionParamRef.subAddTypeList.size() > 0">
            ${_conditionType_} a.subAddType in
            <foreach collection="conditionParamRef.subAddTypeList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('subAddTypeNotList') and conditionParamRef.subAddTypeNotList.size() > 0">
            ${_conditionType_} a.subAddType not in
            <foreach collection="conditionParamRef.subAddTypeNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('subAddTypeStart') and conditionParamRef.subAddTypeStart != null">
            ${_conditionType_} a.subAddType <![CDATA[ >= ]]> #{${_conditionParam_}.subAddTypeStart}
        </if>
        <if test="conditionParamRef.containsKey('subAddTypeEnd') and conditionParamRef.subAddTypeEnd != null">
            ${_conditionType_} a.subAddType <![CDATA[ <= ]]> #{${_conditionParam_}.subAddTypeEnd}
        </if>

        <if test="conditionParamRef.containsKey('score')">
            <if test="conditionParamRef.score != null ">
                ${_conditionType_} a.score = #{${_conditionParam_}.score}
            </if>
            <if test="conditionParamRef.score == null">
                ${_conditionType_} a.score is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('scoreList') and conditionParamRef.scoreList.size() > 0">
            ${_conditionType_} a.score in
            <foreach collection="conditionParamRef.scoreList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('scoreNotList') and conditionParamRef.scoreNotList.size() > 0">
            ${_conditionType_} a.score not in
            <foreach collection="conditionParamRef.scoreNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('scoreStart') and conditionParamRef.scoreStart != null">
            ${_conditionType_} a.score <![CDATA[ >= ]]> #{${_conditionParam_}.scoreStart}
        </if>
        <if test="conditionParamRef.containsKey('scoreEnd') and conditionParamRef.scoreEnd != null">
            ${_conditionType_} a.score <![CDATA[ <= ]]> #{${_conditionParam_}.scoreEnd}
        </if>


        <if test="conditionParamRef.containsKey('goOffTimeStr')">
            <if test="conditionParamRef.goOffTimeStr != null and conditionParamRef.goOffTimeStr != ''">
                ${_conditionType_} a.goOffTimeStr like #{${_conditionParam_}.goOffTimeStr}
            </if>
            <if test="conditionParamRef.goOffTimeStr == null">
                ${_conditionType_} a.goOffTimeStr is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('goOffTimeStrList') and conditionParamRef.goOffTimeStrList.size() > 0">
            ${_conditionType_} a.goOffTimeStr in
            <foreach collection="conditionParamRef.goOffTimeStrList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('goOffTimeStrNotList') and conditionParamRef.goOffTimeStrNotList.size() > 0">
            ${_conditionType_} a.goOffTimeStr not in
            <foreach collection="conditionParamRef.goOffTimeStrNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('errorTime')">
            <if test="conditionParamRef.errorTime != null ">
                ${_conditionType_} a.errorTime = #{${_conditionParam_}.errorTime}
            </if>
            <if test="conditionParamRef.errorTime == null">
                ${_conditionType_} a.errorTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('errorTimeStart') and conditionParamRef.errorTimeStart != null and conditionParamRef.errorTimeStart!=''">
            ${_conditionType_} a.errorTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.errorTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('errorTimeEnd') and conditionParamRef.errorTimeEnd != null and conditionParamRef.errorTimeEnd!=''">
            ${_conditionType_} a.errorTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.errorTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('actualAttendTime')">
            <if test="conditionParamRef.actualAttendTime != null ">
                ${_conditionType_} a.actualAttendTime = #{${_conditionParam_}.actualAttendTime}
            </if>
            <if test="conditionParamRef.actualAttendTime == null">
                ${_conditionType_} a.actualAttendTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('actualAttendTimeStart') and conditionParamRef.actualAttendTimeStart != null and conditionParamRef.actualAttendTimeStart!=''">
            ${_conditionType_} a.actualAttendTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.actualAttendTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('actualAttendTimeEnd') and conditionParamRef.actualAttendTimeEnd != null and conditionParamRef.actualAttendTimeEnd!=''">
            ${_conditionType_} a.actualAttendTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.actualAttendTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('errorResult')">
            <if test="conditionParamRef.errorResult != null and conditionParamRef.errorResult != ''">
                ${_conditionType_} a.errorResult like #{${_conditionParam_}.errorResult}
            </if>
            <if test="conditionParamRef.errorResult == null">
                ${_conditionType_} a.errorResult is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('errorResultList') and conditionParamRef.errorResultList.size() > 0">
            ${_conditionType_} a.errorResult in
            <foreach collection="conditionParamRef.errorResultList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('errorResultNotList') and conditionParamRef.errorResultNotList.size() > 0">
            ${_conditionType_} a.errorResult not in
            <foreach collection="conditionParamRef.errorResultNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('checkPerson')">
            <if test="conditionParamRef.checkPerson != null and conditionParamRef.checkPerson != ''">
                ${_conditionType_} a.checkPerson like #{${_conditionParam_}.checkPerson}
            </if>
            <if test="conditionParamRef.checkPerson == null">
                ${_conditionType_} a.checkPerson is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('checkPersonList') and conditionParamRef.checkPersonList.size() > 0">
            ${_conditionType_} a.checkPerson in
            <foreach collection="conditionParamRef.checkPersonList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('checkPersonNotList') and conditionParamRef.checkPersonNotList.size() > 0">
            ${_conditionType_} a.checkPerson not in
            <foreach collection="conditionParamRef.checkPersonNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('checkTime')">
            <if test="conditionParamRef.checkTime != null ">
                ${_conditionType_} a.checkTime = #{${_conditionParam_}.checkTime}
            </if>
            <if test="conditionParamRef.checkTime == null">
                ${_conditionType_} a.checkTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('checkTimeStart') and conditionParamRef.checkTimeStart != null and conditionParamRef.checkTimeStart!=''">
            ${_conditionType_} a.checkTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.checkTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('checkTimeEnd') and conditionParamRef.checkTimeEnd != null and conditionParamRef.checkTimeEnd!=''">
            ${_conditionType_} a.checkTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.checkTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('checkDesc')">
            <if test="conditionParamRef.checkDesc != null and conditionParamRef.checkDesc != ''">
                ${_conditionType_} a.checkDesc like #{${_conditionParam_}.checkDesc}
            </if>
            <if test="conditionParamRef.checkDesc == null">
                ${_conditionType_} a.checkDesc is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('checkDescList') and conditionParamRef.checkDescList.size() > 0">
            ${_conditionType_} a.checkDesc in
            <foreach collection="conditionParamRef.checkDescList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('checkDescNotList') and conditionParamRef.checkDescNotList.size() > 0">
            ${_conditionType_} a.checkDesc not in
            <foreach collection="conditionParamRef.checkDescNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('checkResult')">
            <if test="conditionParamRef.checkResult != null and conditionParamRef.checkResult != ''">
                ${_conditionType_} a.checkResult like #{${_conditionParam_}.checkResult}
            </if>
            <if test="conditionParamRef.checkResult == null">
                ${_conditionType_} a.checkResult is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('checkResultList') and conditionParamRef.checkResultList.size() > 0">
            ${_conditionType_} a.checkResult in
            <foreach collection="conditionParamRef.checkResultList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('checkResultNotList') and conditionParamRef.checkResultNotList.size() > 0">
            ${_conditionType_} a.checkResult not in
            <foreach collection="conditionParamRef.checkResultNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('processStatus')">
            <if test="conditionParamRef.processStatus != null ">
                ${_conditionType_} a.processStatus = #{${_conditionParam_}.processStatus}
            </if>
            <if test="conditionParamRef.processStatus == null">
                ${_conditionType_} a.processStatus is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('processStatusList') and conditionParamRef.processStatusList.size() > 0">
            ${_conditionType_} a.processStatus in
            <foreach collection="conditionParamRef.processStatusList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('processStatusNotList') and conditionParamRef.processStatusNotList.size() > 0">
            ${_conditionType_} a.processStatus not in
            <foreach collection="conditionParamRef.processStatusNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('processStatusStart') and conditionParamRef.processStatusStart != null">
            ${_conditionType_} a.processStatus <![CDATA[ >= ]]> #{${_conditionParam_}.processStatusStart}
        </if>
        <if test="conditionParamRef.containsKey('processStatusEnd') and conditionParamRef.processStatusEnd != null">
            ${_conditionType_} a.processStatus <![CDATA[ <= ]]> #{${_conditionParam_}.processStatusEnd}
        </if>


        <if test="conditionParamRef.containsKey('appealDesc')">
            <if test="conditionParamRef.appealDesc != null and conditionParamRef.appealDesc != ''">
                ${_conditionType_} a.appealDesc like #{${_conditionParam_}.appealDesc}
            </if>
            <if test="conditionParamRef.appealDesc == null">
                ${_conditionType_} a.appealDesc is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('appealDescList') and conditionParamRef.appealDescList.size() > 0">
            ${_conditionType_} a.appealDesc in
            <foreach collection="conditionParamRef.appealDescList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('appealDescNotList') and conditionParamRef.appealDescNotList.size() > 0">
            ${_conditionType_} a.appealDesc not in
            <foreach collection="conditionParamRef.appealDescNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('appealTime')">
            <if test="conditionParamRef.appealTime != null ">
                ${_conditionType_} a.appealTime = #{${_conditionParam_}.appealTime}
            </if>
            <if test="conditionParamRef.appealTime == null">
                ${_conditionType_} a.appealTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('appealTimeStart') and conditionParamRef.appealTimeStart != null and conditionParamRef.appealTimeStart!=''">
            ${_conditionType_} a.appealTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.appealTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('appealTimeEnd') and conditionParamRef.appealTimeEnd != null and conditionParamRef.appealTimeEnd!=''">
            ${_conditionType_} a.appealTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.appealTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('appealResult')">
            <if test="conditionParamRef.appealResult != null ">
                ${_conditionType_} a.appealResult = #{${_conditionParam_}.appealResult}
            </if>
            <if test="conditionParamRef.appealResult == null">
                ${_conditionType_} a.appealResult is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('appealResultList') and conditionParamRef.appealResultList.size() > 0">
            ${_conditionType_} a.appealResult in
            <foreach collection="conditionParamRef.appealResultList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('appealResultNotList') and conditionParamRef.appealResultNotList.size() > 0">
            ${_conditionType_} a.appealResult not in
            <foreach collection="conditionParamRef.appealResultNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('appealResultStart') and conditionParamRef.appealResultStart != null">
            ${_conditionType_} a.appealResult <![CDATA[ >= ]]> #{${_conditionParam_}.appealResultStart}
        </if>
        <if test="conditionParamRef.containsKey('appealResultEnd') and conditionParamRef.appealResultEnd != null">
            ${_conditionType_} a.appealResult <![CDATA[ <= ]]> #{${_conditionParam_}.appealResultEnd}
        </if>


        <if test="conditionParamRef.containsKey('remark')">
            <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
                ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
            </if>
            <if test="conditionParamRef.remark == null">
                ${_conditionType_} a.remark is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
            ${_conditionType_} a.remark in
            <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
            ${_conditionType_} a.remark not in
            <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('reviewResult')">
            <if test="conditionParamRef.reviewResult != null ">
                ${_conditionType_} a.reviewResult = #{${_conditionParam_}.reviewResult}
            </if>
            <if test="conditionParamRef.reviewResult == null">
                ${_conditionType_} a.reviewResult is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('reviewResultList') and conditionParamRef.reviewResultList.size() > 0">
            ${_conditionType_} a.reviewResult in
            <foreach collection="conditionParamRef.reviewResultList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('reviewResultNotList') and conditionParamRef.reviewResultNotList.size() > 0">
            ${_conditionType_} a.reviewResult not in
            <foreach collection="conditionParamRef.reviewResultNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('reviewResultStart') and conditionParamRef.reviewResultStart != null">
            ${_conditionType_} a.reviewResult <![CDATA[ >= ]]> #{${_conditionParam_}.reviewResultStart}
        </if>
        <if test="conditionParamRef.containsKey('reviewResultEnd') and conditionParamRef.reviewResultEnd != null">
            ${_conditionType_} a.reviewResult <![CDATA[ <= ]]> #{${_conditionParam_}.reviewResultEnd}
        </if>


        <if test="conditionParamRef.containsKey('reviewTime')">
            <if test="conditionParamRef.reviewTime != null ">
                ${_conditionType_} a.reviewTime = #{${_conditionParam_}.reviewTime}
            </if>
            <if test="conditionParamRef.reviewTime == null">
                ${_conditionType_} a.reviewTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('reviewTimeStart') and conditionParamRef.reviewTimeStart != null and conditionParamRef.reviewTimeStart!=''">
            ${_conditionType_} a.reviewTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.reviewTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('reviewTimeEnd') and conditionParamRef.reviewTimeEnd != null and conditionParamRef.reviewTimeEnd!=''">
            ${_conditionType_} a.reviewTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.reviewTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('reviewSource')">
            <if test="conditionParamRef.reviewSource != null and conditionParamRef.reviewSource != ''">
                ${_conditionType_} a.reviewSource like #{${_conditionParam_}.reviewSource}
            </if>
            <if test="conditionParamRef.reviewSource == null">
                ${_conditionType_} a.reviewSource is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('reviewSourceList') and conditionParamRef.reviewSourceList.size() > 0">
            ${_conditionType_} a.reviewSource in
            <foreach collection="conditionParamRef.reviewSourceList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('reviewSourceNotList') and conditionParamRef.reviewSourceNotList.size() > 0">
            ${_conditionType_} a.reviewSource not in
            <foreach collection="conditionParamRef.reviewSourceNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('reviewDevice')">
            <if test="conditionParamRef.reviewDevice != null and conditionParamRef.reviewDevice != ''">
                ${_conditionType_} a.reviewDevice like #{${_conditionParam_}.reviewDevice}
            </if>
            <if test="conditionParamRef.reviewDevice == null">
                ${_conditionType_} a.reviewDevice is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('reviewDeviceList') and conditionParamRef.reviewDeviceList.size() > 0">
            ${_conditionType_} a.reviewDevice in
            <foreach collection="conditionParamRef.reviewDeviceList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('reviewDeviceNotList') and conditionParamRef.reviewDeviceNotList.size() > 0">
            ${_conditionType_} a.reviewDevice not in
            <foreach collection="conditionParamRef.reviewDeviceNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('complainTitle')">
            <if test="conditionParamRef.complainTitle != null and conditionParamRef.complainTitle != ''">
                ${_conditionType_} a.complainTitle like #{${_conditionParam_}.complainTitle}
            </if>
            <if test="conditionParamRef.complainTitle == null">
                ${_conditionType_} a.complainTitle is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('complainTitleList') and conditionParamRef.complainTitleList.size() > 0">
            ${_conditionType_} a.complainTitle in
            <foreach collection="conditionParamRef.complainTitleList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('complainTitleNotList') and conditionParamRef.complainTitleNotList.size() > 0">
            ${_conditionType_} a.complainTitle not in
            <foreach collection="conditionParamRef.complainTitleNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('complainContent')">
            <if test="conditionParamRef.complainContent != null and conditionParamRef.complainContent != ''">
                ${_conditionType_} a.complainContent like #{${_conditionParam_}.complainContent}
            </if>
            <if test="conditionParamRef.complainContent == null">
                ${_conditionType_} a.complainContent is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('complainContentList') and conditionParamRef.complainContentList.size() > 0">
            ${_conditionType_} a.complainContent in
            <foreach collection="conditionParamRef.complainContentList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('complainContentNotList') and conditionParamRef.complainContentNotList.size() > 0">
            ${_conditionType_} a.complainContent not in
            <foreach collection="conditionParamRef.complainContentNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('complainRealName')">
            <if test="conditionParamRef.complainRealName != null and conditionParamRef.complainRealName != ''">
                ${_conditionType_} a.complainRealName like #{${_conditionParam_}.complainRealName}
            </if>
            <if test="conditionParamRef.complainRealName == null">
                ${_conditionType_} a.complainRealName is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('complainRealNameList') and conditionParamRef.complainRealNameList.size() > 0">
            ${_conditionType_} a.complainRealName in
            <foreach collection="conditionParamRef.complainRealNameList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('complainRealNameNotList') and conditionParamRef.complainRealNameNotList.size() > 0">
            ${_conditionType_} a.complainRealName not in
            <foreach collection="conditionParamRef.complainRealNameNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('contact')">
            <if test="conditionParamRef.contact != null and conditionParamRef.contact != ''">
                ${_conditionType_} a.contact like #{${_conditionParam_}.contact}
            </if>
            <if test="conditionParamRef.contact == null">
                ${_conditionType_} a.contact is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('contactList') and conditionParamRef.contactList.size() > 0">
            ${_conditionType_} a.contact in
            <foreach collection="conditionParamRef.contactList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('contactNotList') and conditionParamRef.contactNotList.size() > 0">
            ${_conditionType_} a.contact not in
            <foreach collection="conditionParamRef.contactNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('complainTime')">
            <if test="conditionParamRef.complainTime != null ">
                ${_conditionType_} a.complainTime = #{${_conditionParam_}.complainTime}
            </if>
            <if test="conditionParamRef.complainTime == null">
                ${_conditionType_} a.complainTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('complainTimeStart') and conditionParamRef.complainTimeStart != null and conditionParamRef.complainTimeStart!=''">
            ${_conditionType_} a.complainTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.complainTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('complainTimeEnd') and conditionParamRef.complainTimeEnd != null and conditionParamRef.complainTimeEnd!=''">
            ${_conditionType_} a.complainTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.complainTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('complainSource')">
            <if test="conditionParamRef.complainSource != null and conditionParamRef.complainSource != ''">
                ${_conditionType_} a.complainSource like #{${_conditionParam_}.complainSource}
            </if>
            <if test="conditionParamRef.complainSource == null">
                ${_conditionType_} a.complainSource is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('complainSourceList') and conditionParamRef.complainSourceList.size() > 0">
            ${_conditionType_} a.complainSource in
            <foreach collection="conditionParamRef.complainSourceList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('complainSourceNotList') and conditionParamRef.complainSourceNotList.size() > 0">
            ${_conditionType_} a.complainSource not in
            <foreach collection="conditionParamRef.complainSourceNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('complainDevice')">
            <if test="conditionParamRef.complainDevice != null and conditionParamRef.complainDevice != ''">
                ${_conditionType_} a.complainDevice like #{${_conditionParam_}.complainDevice}
            </if>
            <if test="conditionParamRef.complainDevice == null">
                ${_conditionType_} a.complainDevice is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('complainDeviceList') and conditionParamRef.complainDeviceList.size() > 0">
            ${_conditionType_} a.complainDevice in
            <foreach collection="conditionParamRef.complainDeviceList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('complainDeviceNotList') and conditionParamRef.complainDeviceNotList.size() > 0">
            ${_conditionType_} a.complainDevice not in
            <foreach collection="conditionParamRef.complainDeviceNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('goworkCode')">
            <if test="conditionParamRef.goworkCode != null and conditionParamRef.goworkCode != ''">
                ${_conditionType_} a.goworkCode like #{${_conditionParam_}.goworkCode}
            </if>
            <if test="conditionParamRef.goworkCode == null">
                ${_conditionType_} a.goworkCode is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('goworkCodeList') and conditionParamRef.goworkCodeList.size() > 0">
            ${_conditionType_} a.goworkCode in
            <foreach collection="conditionParamRef.goworkCodeList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('goworkCodeNotList') and conditionParamRef.goworkCodeNotList.size() > 0">
            ${_conditionType_} a.goworkCode not in
            <foreach collection="conditionParamRef.goworkCodeNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('goworkDepts')">
            <if test="conditionParamRef.goworkDepts != null and conditionParamRef.goworkDepts != ''">
                ${_conditionType_} a.goworkDepts like #{${_conditionParam_}.goworkDepts}
            </if>
            <if test="conditionParamRef.goworkDepts == null">
                ${_conditionType_} a.goworkDepts is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('goworkDeptsList') and conditionParamRef.goworkDeptsList.size() > 0">
            ${_conditionType_} a.goworkDepts in
            <foreach collection="conditionParamRef.goworkDeptsList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('goworkDeptsNotList') and conditionParamRef.goworkDeptsNotList.size() > 0">
            ${_conditionType_} a.goworkDepts not in
            <foreach collection="conditionParamRef.goworkDeptsNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('matterlName')">
            <if test="conditionParamRef.matterlName != null and conditionParamRef.matterlName != ''">
                ${_conditionType_} a.matterlName like #{${_conditionParam_}.matterlName}
            </if>
            <if test="conditionParamRef.matterlName == null">
                ${_conditionType_} a.matterlName is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('matterlNameList') and conditionParamRef.matterlNameList.size() > 0">
            ${_conditionType_} a.matterlName in
            <foreach collection="conditionParamRef.matterlNameList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('matterlNameNotList') and conditionParamRef.matterlNameNotList.size() > 0">
            ${_conditionType_} a.matterlName not in
            <foreach collection="conditionParamRef.matterlNameNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('goworkTime')">
            <if test="conditionParamRef.goworkTime != null ">
                ${_conditionType_} a.goworkTime = #{${_conditionParam_}.goworkTime}
            </if>
            <if test="conditionParamRef.goworkTime == null">
                ${_conditionType_} a.goworkTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('goworkTimeStart') and conditionParamRef.goworkTimeStart != null and conditionParamRef.goworkTimeStart!=''">
            ${_conditionType_} a.goworkTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.goworkTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('goworkTimeEnd') and conditionParamRef.goworkTimeEnd != null and conditionParamRef.goworkTimeEnd!=''">
            ${_conditionType_} a.goworkTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.goworkTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('irregularType')">
            <if test="conditionParamRef.irregularType != null ">
                ${_conditionType_} a.irregularType = #{${_conditionParam_}.irregularType}
            </if>
            <if test="conditionParamRef.irregularType == null">
                ${_conditionType_} a.irregularType is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('irregularTypeList') and conditionParamRef.irregularTypeList.size() > 0">
            ${_conditionType_} a.irregularType in
            <foreach collection="conditionParamRef.irregularTypeList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('irregularTypeNotList') and conditionParamRef.irregularTypeNotList.size() > 0">
            ${_conditionType_} a.irregularType not in
            <foreach collection="conditionParamRef.irregularTypeNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('irregularTypeStart') and conditionParamRef.irregularTypeStart != null">
            ${_conditionType_} a.irregularType <![CDATA[ >= ]]> #{${_conditionParam_}.irregularTypeStart}
        </if>
        <if test="conditionParamRef.containsKey('irregularTypeEnd') and conditionParamRef.irregularTypeEnd != null">
            ${_conditionType_} a.irregularType <![CDATA[ <= ]]> #{${_conditionParam_}.irregularTypeEnd}
        </if>


        <if test="conditionParamRef.containsKey('happenTime')">
            <if test="conditionParamRef.happenTime != null ">
                ${_conditionType_} a.happenTime = #{${_conditionParam_}.happenTime}
            </if>
            <if test="conditionParamRef.happenTime == null">
                ${_conditionType_} a.happenTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('happenTimeStart') and conditionParamRef.happenTimeStart != null and conditionParamRef.happenTimeStart!=''">
            ${_conditionType_} a.happenTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.happenTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('happenTimeEnd') and conditionParamRef.happenTimeEnd != null and conditionParamRef.happenTimeEnd!=''">
            ${_conditionType_} a.happenTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.happenTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('duration')">
            <if test="conditionParamRef.duration != null ">
                ${_conditionType_} a.duration = #{${_conditionParam_}.duration}
            </if>
            <if test="conditionParamRef.duration == null">
                ${_conditionType_} a.duration is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('durationList') and conditionParamRef.durationList.size() > 0">
            ${_conditionType_} a.duration in
            <foreach collection="conditionParamRef.durationList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('durationNotList') and conditionParamRef.durationNotList.size() > 0">
            ${_conditionType_} a.duration not in
            <foreach collection="conditionParamRef.durationNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('durationStart') and conditionParamRef.durationStart != null">
            ${_conditionType_} a.duration <![CDATA[ >= ]]> #{${_conditionParam_}.durationStart}
        </if>
        <if test="conditionParamRef.containsKey('durationEnd') and conditionParamRef.durationEnd != null">
            ${_conditionType_} a.duration <![CDATA[ <= ]]> #{${_conditionParam_}.durationEnd}
        </if>


        <if test="conditionParamRef.containsKey('alarmTime')">
            <if test="conditionParamRef.alarmTime != null ">
                ${_conditionType_} a.alarmTime = #{${_conditionParam_}.alarmTime}
            </if>
            <if test="conditionParamRef.alarmTime == null">
                ${_conditionType_} a.alarmTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('alarmTimeStart') and conditionParamRef.alarmTimeStart != null and conditionParamRef.alarmTimeStart!=''">
            ${_conditionType_} a.alarmTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.alarmTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('alarmTimeEnd') and conditionParamRef.alarmTimeEnd != null and conditionParamRef.alarmTimeEnd!=''">
            ${_conditionType_} a.alarmTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.alarmTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('snapPath')">
            <if test="conditionParamRef.snapPath != null and conditionParamRef.snapPath != ''">
                ${_conditionType_} a.snapPath like #{${_conditionParam_}.snapPath}
            </if>
            <if test="conditionParamRef.snapPath == null">
                ${_conditionType_} a.snapPath is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('snapPathList') and conditionParamRef.snapPathList.size() > 0">
            ${_conditionType_} a.snapPath in
            <foreach collection="conditionParamRef.snapPathList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('snapPathNotList') and conditionParamRef.snapPathNotList.size() > 0">
            ${_conditionType_} a.snapPath not in
            <foreach collection="conditionParamRef.snapPathNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('irregularOtherType')">
            <if test="conditionParamRef.irregularOtherType != null ">
                ${_conditionType_} a.irregularOtherType = #{${_conditionParam_}.irregularOtherType}
            </if>
            <if test="conditionParamRef.irregularOtherType == null">
                ${_conditionType_} a.irregularOtherType is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('irregularOtherTypeList') and conditionParamRef.irregularOtherTypeList.size() > 0">
            ${_conditionType_} a.irregularOtherType in
            <foreach collection="conditionParamRef.irregularOtherTypeList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('irregularOtherTypeNotList') and conditionParamRef.irregularOtherTypeNotList.size() > 0">
            ${_conditionType_} a.irregularOtherType not in
            <foreach collection="conditionParamRef.irregularOtherTypeNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('irregularOtherTypeStart') and conditionParamRef.irregularOtherTypeStart != null">
            ${_conditionType_} a.irregularOtherType <![CDATA[ >= ]]> #{${_conditionParam_}.irregularOtherTypeStart}
        </if>
        <if test="conditionParamRef.containsKey('irregularOtherTypeEnd') and conditionParamRef.irregularOtherTypeEnd != null">
            ${_conditionType_} a.irregularOtherType <![CDATA[ <= ]]> #{${_conditionParam_}.irregularOtherTypeEnd}
        </if>


        <if test="conditionParamRef.containsKey('performType')">
            <if test="conditionParamRef.performType != null and conditionParamRef.performType != ''">
                ${_conditionType_} a.performType like #{${_conditionParam_}.performType}
            </if>
            <if test="conditionParamRef.performType == null">
                ${_conditionType_} a.performType is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('performTypeList') and conditionParamRef.performTypeList.size() > 0">
            ${_conditionType_} a.performType in
            <foreach collection="conditionParamRef.performTypeList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('performTypeNotList') and conditionParamRef.performTypeNotList.size() > 0">
            ${_conditionType_} a.performType not in
            <foreach collection="conditionParamRef.performTypeNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('windowNum')">
            <if test="conditionParamRef.windowNum != null and conditionParamRef.windowNum != ''">
                ${_conditionType_} a.windowNum like #{${_conditionParam_}.windowNum}
            </if>
            <if test="conditionParamRef.windowNum == null">
                ${_conditionType_} a.windowNum is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('windowNumList') and conditionParamRef.windowNumList.size() > 0">
            ${_conditionType_} a.windowNum in
            <foreach collection="conditionParamRef.windowNumList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('windowNumNotList') and conditionParamRef.windowNumNotList.size() > 0">
            ${_conditionType_} a.windowNum not in
            <foreach collection="conditionParamRef.windowNumNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('createUserId')">
            <if test="conditionParamRef.createUserId != null ">
                ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
            </if>
            <if test="conditionParamRef.createUserId == null">
                ${_conditionType_} a.createUserId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
            ${_conditionType_} a.createUserId in
            <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
            ${_conditionType_} a.createUserId not in
            <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
            ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
        </if>
        <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
            ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('createTime')">
            <if test="conditionParamRef.createTime != null ">
                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
            </if>
            <if test="conditionParamRef.createTime == null">
                ${_conditionType_} a.createTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
            ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
            ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('updateUserId')">
            <if test="conditionParamRef.updateUserId != null ">
                ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
            </if>
            <if test="conditionParamRef.updateUserId == null">
                ${_conditionType_} a.updateUserId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
            ${_conditionType_} a.updateUserId in
            <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
            ${_conditionType_} a.updateUserId not in
            <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
            ${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
        </if>
        <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
            ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('updateTime')">
            <if test="conditionParamRef.updateTime != null ">
                ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
            </if>
            <if test="conditionParamRef.updateTime == null">
                ${_conditionType_} a.updateTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
            ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
            ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('salaId')">
            <if test="conditionParamRef.salaId != null ">
                ${_conditionType_} a.salaId = #{${_conditionParam_}.salaId}
            </if>
            <if test="conditionParamRef.salaId == null">
                ${_conditionType_} a.salaId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('salaIdList') and conditionParamRef.salaIdList.size() > 0">
            ${_conditionType_} a.salaId in
            <foreach collection="conditionParamRef.salaIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('salaIdNotList') and conditionParamRef.salaIdNotList.size() > 0">
            ${_conditionType_} a.salaId not in
            <foreach collection="conditionParamRef.salaIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('salaIdStart') and conditionParamRef.salaIdStart != null">
            ${_conditionType_} a.salaId <![CDATA[ >= ]]> #{${_conditionParam_}.salaIdStart}
        </if>
        <if test="conditionParamRef.containsKey('salaIdEnd') and conditionParamRef.salaIdEnd != null">
            ${_conditionType_} a.salaId <![CDATA[ <= ]]> #{${_conditionParam_}.salaIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('salaName')">
            <if test="conditionParamRef.salaName != null and conditionParamRef.salaName != ''">
                ${_conditionType_} a.salaName like #{${_conditionParam_}.salaName}
            </if>
            <if test="conditionParamRef.salaName == null">
                ${_conditionType_} a.salaName is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('salaNameList') and conditionParamRef.salaNameList.size() > 0">
            ${_conditionType_} a.salaName in
            <foreach collection="conditionParamRef.salaNameList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('salaNameNotList') and conditionParamRef.salaNameNotList.size() > 0">
            ${_conditionType_} a.salaName not in
            <foreach collection="conditionParamRef.salaNameNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>

        <if test="conditionParamRef.containsKey('checkStatus')">
            <if test="conditionParamRef.checkStatus != null ">
                ${_conditionType_} a.checkStatus = #{${_conditionParam_}.checkStatus}
            </if>
            <if test="conditionParamRef.checkStatus == null">
                ${_conditionType_} a.checkStatus is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('checkStatusList') and conditionParamRef.checkStatusList.size() > 0">
            ${_conditionType_} a.checkStatus in
            <foreach collection="conditionParamRef.checkStatusList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('checkStatusNotList') and conditionParamRef.checkStatusNotList.size() > 0">
            ${_conditionType_} a.checkStatus not in
            <foreach collection="conditionParamRef.checkStatusNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('checkStatusStart') and conditionParamRef.checkStatusStart != null">
            ${_conditionType_} a.checkStatus <![CDATA[ >= ]]> #{${_conditionParam_}.checkStatusStart}
        </if>
        <if test="conditionParamRef.containsKey('checkStatusEnd') and conditionParamRef.checkStatusEnd != null">
            ${_conditionType_} a.checkStatus <![CDATA[ <= ]]> #{${_conditionParam_}.checkStatusEnd}
        </if>
        <if test="conditionParamRef.containsKey('appealPersonId')">
            <if test="conditionParamRef.appealPersonId != null ">
                ${_conditionType_} a.appealPersonId = #{${_conditionParam_}.appealPersonId}
            </if>
            <if test="conditionParamRef.appealPersonId == null">
                ${_conditionType_} a.appealPersonId is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('appealPersonIdList') and conditionParamRef.appealPersonIdList.size() > 0">
            ${_conditionType_} a.appealPersonId in
            <foreach collection="conditionParamRef.appealPersonIdList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('appealPersonIdNotList') and conditionParamRef.appealPersonIdNotList.size() > 0">
            ${_conditionType_} a.appealPersonId not in
            <foreach collection="conditionParamRef.appealPersonIdNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('appealPersonIdStart') and conditionParamRef.appealPersonIdStart != null">
            ${_conditionType_} a.appealPersonId <![CDATA[ >= ]]> #{${_conditionParam_}.appealPersonIdStart}
        </if>
        <if test="conditionParamRef.containsKey('appealPersonIdEnd') and conditionParamRef.appealPersonIdEnd != null">
            ${_conditionType_} a.appealPersonId <![CDATA[ <= ]]> #{${_conditionParam_}.appealPersonIdEnd}
        </if>


        <if test="conditionParamRef.containsKey('appealPerson')">
            <if test="conditionParamRef.appealPerson != null and conditionParamRef.appealPerson != ''">
                ${_conditionType_} a.appealPerson like #{${_conditionParam_}.appealPerson}
            </if>
            <if test="conditionParamRef.appealPerson == null">
                ${_conditionType_} a.appealPerson is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('appealPersonList') and conditionParamRef.appealPersonList.size() > 0">
            ${_conditionType_} a.appealPerson in
            <foreach collection="conditionParamRef.appealPersonList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('appealPersonNotList') and conditionParamRef.appealPersonNotList.size() > 0">
            ${_conditionType_} a.appealPerson not in
            <foreach collection="conditionParamRef.appealPersonNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('processTime')">
            <if test="conditionParamRef.processTime != null ">
                ${_conditionType_} a.processTime = #{${_conditionParam_}.processTime}
            </if>
            <if test="conditionParamRef.processTime == null">
                ${_conditionType_} a.processTime is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('processTimeStart') and conditionParamRef.processTimeStart != null and conditionParamRef.processTimeStart!=''">
            ${_conditionType_} a.processTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.processTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
        </if>
        <if test="conditionParamRef.containsKey('processTimeEnd') and conditionParamRef.processTimeEnd != null and conditionParamRef.processTimeEnd!=''">
            ${_conditionType_} a.processTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.processTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
        </if>

        <if test="conditionParamRef.containsKey('processPerson')">
            <if test="conditionParamRef.processPerson != null and conditionParamRef.processPerson != ''">
                ${_conditionType_} a.processPerson like #{${_conditionParam_}.processPerson}
            </if>
            <if test="conditionParamRef.processPerson == null">
                ${_conditionType_} a.processPerson is null
            </if>
        </if>
        <if test="conditionParamRef.containsKey('processPersonList') and conditionParamRef.processPersonList.size() > 0">
            ${_conditionType_} a.processPerson in
            <foreach collection="conditionParamRef.processPersonList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
        <if test="conditionParamRef.containsKey('processPersonNotList') and conditionParamRef.processPersonNotList.size() > 0">
            ${_conditionType_} a.processPerson not in
            <foreach collection="conditionParamRef.processPersonNotList" open="(" close=")" index="index" item="item" separator=",">
                #{item}
            </foreach>
        </if>
    </sql>
</mapper>