package com.mortals.xhx.module.appointment.model;

import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.appointment.model.AppointmentConstraintEntity;
/**
* 预约自动签到服务约束查询对象
*
* @author zxfei
* @date 2023-04-09
*/
public class AppointmentConstraintQuery extends AppointmentConstraintEntity {
    /** 开始 主键ID，主键，自增长 */
    private Long idStart;

    /** 结束 主键ID，主键，自增长 */
    private Long idEnd;

    /** 增加 主键ID，主键，自增长 */
    private Long idIncrement;

    /** 主键ID，主键，自增长列表 */
    private List <Long> idList;

    /** 主键ID，主键，自增长排除列表 */
    private List <Long> idNotList;

    /** 开始 站点Id */
    private Long siteIdStart;

    /** 结束 站点Id */
    private Long siteIdEnd;

    /** 增加 站点Id */
    private Long siteIdIncrement;

    /** 站点Id列表 */
    private List <Long> siteIdList;

    /** 站点Id排除列表 */
    private List <Long> siteIdNotList;

    /** 站点名称 */
    private List<String> siteNameList;

    /** 站点名称排除列表 */
    private List <String> siteNameNotList;
    /** 开始 个人信息ID */
    private Long personIdStart;

    /** 结束 个人信息ID */
    private Long personIdEnd;

    /** 增加 个人信息ID */
    private Long personIdIncrement;

    /** 个人信息ID列表 */
    private List <Long> personIdList;

    /** 个人信息ID排除列表 */
    private List <Long> personIdNotList;

    /** 姓名 */
    private List<String> nameList;

    /** 姓名排除列表 */
    private List <String> nameNotList;
    /** 联系方式 */
    private List<String> contactList;

    /** 联系方式排除列表 */
    private List <String> contactNotList;
    /** 证件类型 */
    private List<String> idCardTypeList;

    /** 证件类型排除列表 */
    private List <String> idCardTypeNotList;
    /** 证件号码 */
    private List<String> idCardNoList;

    /** 证件号码排除列表 */
    private List <String> idCardNoNotList;
    /** 开始 累计次数 */
    private Long accumulativeStart;

    /** 结束 累计次数 */
    private Long accumulativeEnd;

    /** 增加 累计次数 */
    private Long accumulativeIncrement;

    /** 累计次数列表 */
    private List <Long> accumulativeList;

    /** 累计次数排除列表 */
    private List <Long> accumulativeNotList;

    /** 开始 约束时间 */
    private String constraintTimeStart;

    /** 结束 约束时间 */
    private String constraintTimeEnd;

    /** 开始 创建方式(0.手动创建，1.系统推荐) */
    private Integer createMethodStart;

    /** 结束 创建方式(0.手动创建，1.系统推荐) */
    private Integer createMethodEnd;

    /** 增加 创建方式(0.手动创建，1.系统推荐) */
    private Integer createMethodIncrement;

    /** 创建方式(0.手动创建，1.系统推荐)列表 */
    private List <Integer> createMethodList;

    /** 创建方式(0.手动创建，1.系统推荐)排除列表 */
    private List <Integer> createMethodNotList;

    /** 操作人员 */
    private List<String> operatorList;

    /** 操作人员排除列表 */
    private List <String> operatorNotList;
    /** 开始 是否约束 (0.否，1.是) */
    private Integer constraintStart;

    /** 结束 是否约束 (0.否，1.是) */
    private Integer constraintEnd;

    /** 增加 是否约束 (0.否，1.是) */
    private Integer constraintIncrement;

    /** 是否约束 (0.否，1.是)列表 */
    private List <Integer> constraintList;

    /** 是否约束 (0.否，1.是)排除列表 */
    private List <Integer> constraintNotList;

    /** 开始 创建时间 */
    private String createTimeStart;

    /** 结束 创建时间 */
    private String createTimeEnd;

    /** 开始 创建人ID */
    private Long createUserIdStart;

    /** 结束 创建人ID */
    private Long createUserIdEnd;

    /** 增加 创建人ID */
    private Long createUserIdIncrement;

    /** 创建人ID列表 */
    private List <Long> createUserIdList;

    /** 创建人ID排除列表 */
    private List <Long> createUserIdNotList;

    /** 开始 更新时间 */
    private String updateTimeStart;

    /** 结束 更新时间 */
    private String updateTimeEnd;

    /** 开始 更新人ID */
    private Long updateUserIdStart;

    /** 结束 更新人ID */
    private Long updateUserIdEnd;

    /** 增加 更新人ID */
    private Long updateUserIdIncrement;

    /** 更新人ID列表 */
    private List <Long> updateUserIdList;

    /** 更新人ID排除列表 */
    private List <Long> updateUserIdNotList;

    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
    private List<AppointmentConstraintQuery> orConditionList;

    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
    private List<AppointmentConstraintQuery> andConditionList;

    public AppointmentConstraintQuery(){}

    /**
    * 获取 开始 主键ID，主键，自增长
    * @return idStart
    */
    public Long getIdStart(){
        return this.idStart;
    }

    /**
    * 设置 开始 主键ID，主键，自增长
    * @param idStart
    */
    public void setIdStart(Long idStart){
        this.idStart = idStart;
    }

    /**
    * 获取 结束 主键ID，主键，自增长
    * @return $idEnd
    */
    public Long getIdEnd(){
        return this.idEnd;
    }

    /**
    * 设置 结束 主键ID，主键，自增长
    * @param idEnd
    */
    public void setIdEnd(Long idEnd){
        this.idEnd = idEnd;
    }

    /**
    * 获取 增加 主键ID，主键，自增长
    * @return idIncrement
    */
    public Long getIdIncrement(){
        return this.idIncrement;
    }

    /**
    * 设置 增加 主键ID，主键，自增长
    * @param idIncrement
    */
    public void setIdIncrement(Long idIncrement){
        this.idIncrement = idIncrement;
    }

    /**
    * 获取 主键ID，主键，自增长
    * @return idList
    */
    public List<Long> getIdList(){
        return this.idList;
    }

    /**
    * 设置 主键ID，主键，自增长
    * @param idList
    */
    public void setIdList(List<Long> idList){
        this.idList = idList;
    }

    /**
    * 获取 主键ID，主键，自增长
    * @return idNotList
    */
    public List<Long> getIdNotList(){
        return this.idNotList;
    }

    /**
    * 设置 主键ID，主键，自增长
    * @param idNotList
    */
    public void setIdNotList(List<Long> idNotList){
        this.idNotList = idNotList;
    }


    /**
    * 获取 开始 站点Id
    * @return siteIdStart
    */
    public Long getSiteIdStart(){
        return this.siteIdStart;
    }

    /**
    * 设置 开始 站点Id
    * @param siteIdStart
    */
    public void setSiteIdStart(Long siteIdStart){
        this.siteIdStart = siteIdStart;
    }

    /**
    * 获取 结束 站点Id
    * @return $siteIdEnd
    */
    public Long getSiteIdEnd(){
        return this.siteIdEnd;
    }

    /**
    * 设置 结束 站点Id
    * @param siteIdEnd
    */
    public void setSiteIdEnd(Long siteIdEnd){
        this.siteIdEnd = siteIdEnd;
    }

    /**
    * 获取 增加 站点Id
    * @return siteIdIncrement
    */
    public Long getSiteIdIncrement(){
        return this.siteIdIncrement;
    }

    /**
    * 设置 增加 站点Id
    * @param siteIdIncrement
    */
    public void setSiteIdIncrement(Long siteIdIncrement){
        this.siteIdIncrement = siteIdIncrement;
    }

    /**
    * 获取 站点Id
    * @return siteIdList
    */
    public List<Long> getSiteIdList(){
        return this.siteIdList;
    }

    /**
    * 设置 站点Id
    * @param siteIdList
    */
    public void setSiteIdList(List<Long> siteIdList){
        this.siteIdList = siteIdList;
    }

    /**
    * 获取 站点Id
    * @return siteIdNotList
    */
    public List<Long> getSiteIdNotList(){
        return this.siteIdNotList;
    }

    /**
    * 设置 站点Id
    * @param siteIdNotList
    */
    public void setSiteIdNotList(List<Long> siteIdNotList){
        this.siteIdNotList = siteIdNotList;
    }


    /**
    * 获取 站点名称
    * @return siteNameList
    */
    public List<String> getSiteNameList(){
        return this.siteNameList;
    }

    /**
    * 设置 站点名称
    * @param siteNameList
    */
    public void setSiteNameList(List<String> siteNameList){
        this.siteNameList = siteNameList;
    }

    /**
    * 获取 站点名称
    * @return siteNameNotList
    */
    public List<String> getSiteNameNotList(){
        return this.siteNameNotList;
    }

    /**
    * 设置 站点名称
    * @param siteNameNotList
    */
    public void setSiteNameNotList(List<String> siteNameNotList){
        this.siteNameNotList = siteNameNotList;
    }

    /**
    * 获取 开始 个人信息ID
    * @return personIdStart
    */
    public Long getPersonIdStart(){
        return this.personIdStart;
    }

    /**
    * 设置 开始 个人信息ID
    * @param personIdStart
    */
    public void setPersonIdStart(Long personIdStart){
        this.personIdStart = personIdStart;
    }

    /**
    * 获取 结束 个人信息ID
    * @return $personIdEnd
    */
    public Long getPersonIdEnd(){
        return this.personIdEnd;
    }

    /**
    * 设置 结束 个人信息ID
    * @param personIdEnd
    */
    public void setPersonIdEnd(Long personIdEnd){
        this.personIdEnd = personIdEnd;
    }

    /**
    * 获取 增加 个人信息ID
    * @return personIdIncrement
    */
    public Long getPersonIdIncrement(){
        return this.personIdIncrement;
    }

    /**
    * 设置 增加 个人信息ID
    * @param personIdIncrement
    */
    public void setPersonIdIncrement(Long personIdIncrement){
        this.personIdIncrement = personIdIncrement;
    }

    /**
    * 获取 个人信息ID
    * @return personIdList
    */
    public List<Long> getPersonIdList(){
        return this.personIdList;
    }

    /**
    * 设置 个人信息ID
    * @param personIdList
    */
    public void setPersonIdList(List<Long> personIdList){
        this.personIdList = personIdList;
    }

    /**
    * 获取 个人信息ID
    * @return personIdNotList
    */
    public List<Long> getPersonIdNotList(){
        return this.personIdNotList;
    }

    /**
    * 设置 个人信息ID
    * @param personIdNotList
    */
    public void setPersonIdNotList(List<Long> personIdNotList){
        this.personIdNotList = personIdNotList;
    }


    /**
    * 获取 姓名
    * @return nameList
    */
    public List<String> getNameList(){
        return this.nameList;
    }

    /**
    * 设置 姓名
    * @param nameList
    */
    public void setNameList(List<String> nameList){
        this.nameList = nameList;
    }

    /**
    * 获取 姓名
    * @return nameNotList
    */
    public List<String> getNameNotList(){
        return this.nameNotList;
    }

    /**
    * 设置 姓名
    * @param nameNotList
    */
    public void setNameNotList(List<String> nameNotList){
        this.nameNotList = nameNotList;
    }

    /**
    * 获取 联系方式
    * @return contactList
    */
    public List<String> getContactList(){
        return this.contactList;
    }

    /**
    * 设置 联系方式
    * @param contactList
    */
    public void setContactList(List<String> contactList){
        this.contactList = contactList;
    }

    /**
    * 获取 联系方式
    * @return contactNotList
    */
    public List<String> getContactNotList(){
        return this.contactNotList;
    }

    /**
    * 设置 联系方式
    * @param contactNotList
    */
    public void setContactNotList(List<String> contactNotList){
        this.contactNotList = contactNotList;
    }

    /**
    * 获取 证件类型
    * @return idCardTypeList
    */
    public List<String> getIdCardTypeList(){
        return this.idCardTypeList;
    }

    /**
    * 设置 证件类型
    * @param idCardTypeList
    */
    public void setIdCardTypeList(List<String> idCardTypeList){
        this.idCardTypeList = idCardTypeList;
    }

    /**
    * 获取 证件类型
    * @return idCardTypeNotList
    */
    public List<String> getIdCardTypeNotList(){
        return this.idCardTypeNotList;
    }

    /**
    * 设置 证件类型
    * @param idCardTypeNotList
    */
    public void setIdCardTypeNotList(List<String> idCardTypeNotList){
        this.idCardTypeNotList = idCardTypeNotList;
    }

    /**
    * 获取 证件号码
    * @return idCardNoList
    */
    public List<String> getIdCardNoList(){
        return this.idCardNoList;
    }

    /**
    * 设置 证件号码
    * @param idCardNoList
    */
    public void setIdCardNoList(List<String> idCardNoList){
        this.idCardNoList = idCardNoList;
    }

    /**
    * 获取 证件号码
    * @return idCardNoNotList
    */
    public List<String> getIdCardNoNotList(){
        return this.idCardNoNotList;
    }

    /**
    * 设置 证件号码
    * @param idCardNoNotList
    */
    public void setIdCardNoNotList(List<String> idCardNoNotList){
        this.idCardNoNotList = idCardNoNotList;
    }

    /**
    * 获取 开始 累计次数
    * @return accumulativeStart
    */
    public Long getAccumulativeStart(){
        return this.accumulativeStart;
    }

    /**
    * 设置 开始 累计次数
    * @param accumulativeStart
    */
    public void setAccumulativeStart(Long accumulativeStart){
        this.accumulativeStart = accumulativeStart;
    }

    /**
    * 获取 结束 累计次数
    * @return $accumulativeEnd
    */
    public Long getAccumulativeEnd(){
        return this.accumulativeEnd;
    }

    /**
    * 设置 结束 累计次数
    * @param accumulativeEnd
    */
    public void setAccumulativeEnd(Long accumulativeEnd){
        this.accumulativeEnd = accumulativeEnd;
    }

    /**
    * 获取 增加 累计次数
    * @return accumulativeIncrement
    */
    public Long getAccumulativeIncrement(){
        return this.accumulativeIncrement;
    }

    /**
    * 设置 增加 累计次数
    * @param accumulativeIncrement
    */
    public void setAccumulativeIncrement(Long accumulativeIncrement){
        this.accumulativeIncrement = accumulativeIncrement;
    }

    /**
    * 获取 累计次数
    * @return accumulativeList
    */
    public List<Long> getAccumulativeList(){
        return this.accumulativeList;
    }

    /**
    * 设置 累计次数
    * @param accumulativeList
    */
    public void setAccumulativeList(List<Long> accumulativeList){
        this.accumulativeList = accumulativeList;
    }

    /**
    * 获取 累计次数
    * @return accumulativeNotList
    */
    public List<Long> getAccumulativeNotList(){
        return this.accumulativeNotList;
    }

    /**
    * 设置 累计次数
    * @param accumulativeNotList
    */
    public void setAccumulativeNotList(List<Long> accumulativeNotList){
        this.accumulativeNotList = accumulativeNotList;
    }


    /**
    * 获取 开始 约束时间
    * @return constraintTimeStart
    */
    public String getConstraintTimeStart(){
        return this.constraintTimeStart;
    }

    /**
    * 设置 开始 约束时间
    * @param constraintTimeStart
    */
    public void setConstraintTimeStart(String constraintTimeStart){
        this.constraintTimeStart = constraintTimeStart;
    }

    /**
    * 获取 结束 约束时间
    * @return constraintTimeEnd
    */
    public String getConstraintTimeEnd(){
        return this.constraintTimeEnd;
    }

    /**
    * 设置 结束 约束时间
    * @param constraintTimeEnd
    */
    public void setConstraintTimeEnd(String constraintTimeEnd){
        this.constraintTimeEnd = constraintTimeEnd;
    }

    /**
    * 获取 开始 创建方式(0.手动创建，1.系统推荐)
    * @return createMethodStart
    */
    public Integer getCreateMethodStart(){
        return this.createMethodStart;
    }

    /**
    * 设置 开始 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodStart
    */
    public void setCreateMethodStart(Integer createMethodStart){
        this.createMethodStart = createMethodStart;
    }

    /**
    * 获取 结束 创建方式(0.手动创建，1.系统推荐)
    * @return $createMethodEnd
    */
    public Integer getCreateMethodEnd(){
        return this.createMethodEnd;
    }

    /**
    * 设置 结束 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodEnd
    */
    public void setCreateMethodEnd(Integer createMethodEnd){
        this.createMethodEnd = createMethodEnd;
    }

    /**
    * 获取 增加 创建方式(0.手动创建，1.系统推荐)
    * @return createMethodIncrement
    */
    public Integer getCreateMethodIncrement(){
        return this.createMethodIncrement;
    }

    /**
    * 设置 增加 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodIncrement
    */
    public void setCreateMethodIncrement(Integer createMethodIncrement){
        this.createMethodIncrement = createMethodIncrement;
    }

    /**
    * 获取 创建方式(0.手动创建，1.系统推荐)
    * @return createMethodList
    */
    public List<Integer> getCreateMethodList(){
        return this.createMethodList;
    }

    /**
    * 设置 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodList
    */
    public void setCreateMethodList(List<Integer> createMethodList){
        this.createMethodList = createMethodList;
    }

    /**
    * 获取 创建方式(0.手动创建，1.系统推荐)
    * @return createMethodNotList
    */
    public List<Integer> getCreateMethodNotList(){
        return this.createMethodNotList;
    }

    /**
    * 设置 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodNotList
    */
    public void setCreateMethodNotList(List<Integer> createMethodNotList){
        this.createMethodNotList = createMethodNotList;
    }


    /**
    * 获取 操作人员
    * @return operatorList
    */
    public List<String> getOperatorList(){
        return this.operatorList;
    }

    /**
    * 设置 操作人员
    * @param operatorList
    */
    public void setOperatorList(List<String> operatorList){
        this.operatorList = operatorList;
    }

    /**
    * 获取 操作人员
    * @return operatorNotList
    */
    public List<String> getOperatorNotList(){
        return this.operatorNotList;
    }

    /**
    * 设置 操作人员
    * @param operatorNotList
    */
    public void setOperatorNotList(List<String> operatorNotList){
        this.operatorNotList = operatorNotList;
    }

    /**
    * 获取 开始 是否约束 (0.否，1.是)
    * @return constraintStart
    */
    public Integer getConstraintStart(){
        return this.constraintStart;
    }

    /**
    * 设置 开始 是否约束 (0.否，1.是)
    * @param constraintStart
    */
    public void setConstraintStart(Integer constraintStart){
        this.constraintStart = constraintStart;
    }

    /**
    * 获取 结束 是否约束 (0.否，1.是)
    * @return $constraintEnd
    */
    public Integer getConstraintEnd(){
        return this.constraintEnd;
    }

    /**
    * 设置 结束 是否约束 (0.否，1.是)
    * @param constraintEnd
    */
    public void setConstraintEnd(Integer constraintEnd){
        this.constraintEnd = constraintEnd;
    }

    /**
    * 获取 增加 是否约束 (0.否，1.是)
    * @return constraintIncrement
    */
    public Integer getConstraintIncrement(){
        return this.constraintIncrement;
    }

    /**
    * 设置 增加 是否约束 (0.否，1.是)
    * @param constraintIncrement
    */
    public void setConstraintIncrement(Integer constraintIncrement){
        this.constraintIncrement = constraintIncrement;
    }

    /**
    * 获取 是否约束 (0.否，1.是)
    * @return constraintList
    */
    public List<Integer> getConstraintList(){
        return this.constraintList;
    }

    /**
    * 设置 是否约束 (0.否，1.是)
    * @param constraintList
    */
    public void setConstraintList(List<Integer> constraintList){
        this.constraintList = constraintList;
    }

    /**
    * 获取 是否约束 (0.否，1.是)
    * @return constraintNotList
    */
    public List<Integer> getConstraintNotList(){
        return this.constraintNotList;
    }

    /**
    * 设置 是否约束 (0.否，1.是)
    * @param constraintNotList
    */
    public void setConstraintNotList(List<Integer> constraintNotList){
        this.constraintNotList = constraintNotList;
    }


    /**
    * 获取 开始 创建时间
    * @return createTimeStart
    */
    public String getCreateTimeStart(){
        return this.createTimeStart;
    }

    /**
    * 设置 开始 创建时间
    * @param createTimeStart
    */
    public void setCreateTimeStart(String createTimeStart){
        this.createTimeStart = createTimeStart;
    }

    /**
    * 获取 结束 创建时间
    * @return createTimeEnd
    */
    public String getCreateTimeEnd(){
        return this.createTimeEnd;
    }

    /**
    * 设置 结束 创建时间
    * @param createTimeEnd
    */
    public void setCreateTimeEnd(String createTimeEnd){
        this.createTimeEnd = createTimeEnd;
    }

    /**
    * 获取 开始 创建人ID
    * @return createUserIdStart
    */
    public Long getCreateUserIdStart(){
        return this.createUserIdStart;
    }

    /**
    * 设置 开始 创建人ID
    * @param createUserIdStart
    */
    public void setCreateUserIdStart(Long createUserIdStart){
        this.createUserIdStart = createUserIdStart;
    }

    /**
    * 获取 结束 创建人ID
    * @return $createUserIdEnd
    */
    public Long getCreateUserIdEnd(){
        return this.createUserIdEnd;
    }

    /**
    * 设置 结束 创建人ID
    * @param createUserIdEnd
    */
    public void setCreateUserIdEnd(Long createUserIdEnd){
        this.createUserIdEnd = createUserIdEnd;
    }

    /**
    * 获取 增加 创建人ID
    * @return createUserIdIncrement
    */
    public Long getCreateUserIdIncrement(){
        return this.createUserIdIncrement;
    }

    /**
    * 设置 增加 创建人ID
    * @param createUserIdIncrement
    */
    public void setCreateUserIdIncrement(Long createUserIdIncrement){
        this.createUserIdIncrement = createUserIdIncrement;
    }

    /**
    * 获取 创建人ID
    * @return createUserIdList
    */
    public List<Long> getCreateUserIdList(){
        return this.createUserIdList;
    }

    /**
    * 设置 创建人ID
    * @param createUserIdList
    */
    public void setCreateUserIdList(List<Long> createUserIdList){
        this.createUserIdList = createUserIdList;
    }

    /**
    * 获取 创建人ID
    * @return createUserIdNotList
    */
    public List<Long> getCreateUserIdNotList(){
        return this.createUserIdNotList;
    }

    /**
    * 设置 创建人ID
    * @param createUserIdNotList
    */
    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
        this.createUserIdNotList = createUserIdNotList;
    }


    /**
    * 获取 开始 更新时间
    * @return updateTimeStart
    */
    public String getUpdateTimeStart(){
        return this.updateTimeStart;
    }

    /**
    * 设置 开始 更新时间
    * @param updateTimeStart
    */
    public void setUpdateTimeStart(String updateTimeStart){
        this.updateTimeStart = updateTimeStart;
    }

    /**
    * 获取 结束 更新时间
    * @return updateTimeEnd
    */
    public String getUpdateTimeEnd(){
        return this.updateTimeEnd;
    }

    /**
    * 设置 结束 更新时间
    * @param updateTimeEnd
    */
    public void setUpdateTimeEnd(String updateTimeEnd){
        this.updateTimeEnd = updateTimeEnd;
    }

    /**
    * 获取 开始 更新人ID
    * @return updateUserIdStart
    */
    public Long getUpdateUserIdStart(){
        return this.updateUserIdStart;
    }

    /**
    * 设置 开始 更新人ID
    * @param updateUserIdStart
    */
    public void setUpdateUserIdStart(Long updateUserIdStart){
        this.updateUserIdStart = updateUserIdStart;
    }

    /**
    * 获取 结束 更新人ID
    * @return $updateUserIdEnd
    */
    public Long getUpdateUserIdEnd(){
        return this.updateUserIdEnd;
    }

    /**
    * 设置 结束 更新人ID
    * @param updateUserIdEnd
    */
    public void setUpdateUserIdEnd(Long updateUserIdEnd){
        this.updateUserIdEnd = updateUserIdEnd;
    }

    /**
    * 获取 增加 更新人ID
    * @return updateUserIdIncrement
    */
    public Long getUpdateUserIdIncrement(){
        return this.updateUserIdIncrement;
    }

    /**
    * 设置 增加 更新人ID
    * @param updateUserIdIncrement
    */
    public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
        this.updateUserIdIncrement = updateUserIdIncrement;
    }

    /**
    * 获取 更新人ID
    * @return updateUserIdList
    */
    public List<Long> getUpdateUserIdList(){
        return this.updateUserIdList;
    }

    /**
    * 设置 更新人ID
    * @param updateUserIdList
    */
    public void setUpdateUserIdList(List<Long> updateUserIdList){
        this.updateUserIdList = updateUserIdList;
    }

    /**
    * 获取 更新人ID
    * @return updateUserIdNotList
    */
    public List<Long> getUpdateUserIdNotList(){
        return this.updateUserIdNotList;
    }

    /**
    * 设置 更新人ID
    * @param updateUserIdNotList
    */
    public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
        this.updateUserIdNotList = updateUserIdNotList;
    }


    /**
    * 设置  主键ID，主键，自增长
    * @param id
    */
    public AppointmentConstraintQuery id(Long id){
	    setId(id);
		return this;
    }
	
	 /**
    * 设置 开始 主键ID，主键，自增长
    * @param idStart
    */
    public AppointmentConstraintQuery idStart(Long idStart){
		this.idStart = idStart;
		return this;
    }

    /**
    * 设置 结束 主键ID，主键，自增长
    * @param idEnd
    */
    public AppointmentConstraintQuery idEnd(Long idEnd){
		this.idEnd = idEnd;
		return this;
    }

    /**
    * 设置 增加 主键ID，主键，自增长
    * @param idIncrement
    */
    public AppointmentConstraintQuery idIncrement(Long idIncrement){
		this.idIncrement = idIncrement;
		return this;
    }

    /**
    * 设置 主键ID，主键，自增长
    * @param idList
    */
    public AppointmentConstraintQuery idList(List<Long> idList){
        this.idList = idList;
		return this;
        }

        /**
        * 设置 主键ID，主键，自增长
        * @param idNotList
        */
        public AppointmentConstraintQuery idNotList(List<Long> idNotList){
        this.idNotList = idNotList;
        return this;
        }

    /**
    * 设置  站点Id
    * @param siteId
    */
    public AppointmentConstraintQuery siteId(Long siteId){
	    setSiteId(siteId);
		return this;
    }
	
	 /**
    * 设置 开始 站点Id
    * @param siteIdStart
    */
    public AppointmentConstraintQuery siteIdStart(Long siteIdStart){
		this.siteIdStart = siteIdStart;
		return this;
    }

    /**
    * 设置 结束 站点Id
    * @param siteIdEnd
    */
    public AppointmentConstraintQuery siteIdEnd(Long siteIdEnd){
		this.siteIdEnd = siteIdEnd;
		return this;
    }

    /**
    * 设置 增加 站点Id
    * @param siteIdIncrement
    */
    public AppointmentConstraintQuery siteIdIncrement(Long siteIdIncrement){
		this.siteIdIncrement = siteIdIncrement;
		return this;
    }

    /**
    * 设置 站点Id
    * @param siteIdList
    */
    public AppointmentConstraintQuery siteIdList(List<Long> siteIdList){
        this.siteIdList = siteIdList;
		return this;
        }

        /**
        * 设置 站点Id
        * @param siteIdNotList
        */
        public AppointmentConstraintQuery siteIdNotList(List<Long> siteIdNotList){
        this.siteIdNotList = siteIdNotList;
        return this;
        }


	/**
    * 设置 站点名称
    * @param siteName
    */
    public AppointmentConstraintQuery siteName(String siteName){
        setSiteName(siteName);
		return this;
    }

    /**
    * 设置 站点名称
    * @param siteNameList
    */
    public AppointmentConstraintQuery siteNameList(List<String> siteNameList){
        this.siteNameList = siteNameList;
		return this;
    }

    /**
    * 设置  个人信息ID
    * @param personId
    */
    public AppointmentConstraintQuery personId(Long personId){
	    setPersonId(personId);
		return this;
    }
	
	 /**
    * 设置 开始 个人信息ID
    * @param personIdStart
    */
    public AppointmentConstraintQuery personIdStart(Long personIdStart){
		this.personIdStart = personIdStart;
		return this;
    }

    /**
    * 设置 结束 个人信息ID
    * @param personIdEnd
    */
    public AppointmentConstraintQuery personIdEnd(Long personIdEnd){
		this.personIdEnd = personIdEnd;
		return this;
    }

    /**
    * 设置 增加 个人信息ID
    * @param personIdIncrement
    */
    public AppointmentConstraintQuery personIdIncrement(Long personIdIncrement){
		this.personIdIncrement = personIdIncrement;
		return this;
    }

    /**
    * 设置 个人信息ID
    * @param personIdList
    */
    public AppointmentConstraintQuery personIdList(List<Long> personIdList){
        this.personIdList = personIdList;
		return this;
        }

        /**
        * 设置 个人信息ID
        * @param personIdNotList
        */
        public AppointmentConstraintQuery personIdNotList(List<Long> personIdNotList){
        this.personIdNotList = personIdNotList;
        return this;
        }


	/**
    * 设置 姓名
    * @param name
    */
    public AppointmentConstraintQuery name(String name){
        setName(name);
		return this;
    }

    /**
    * 设置 姓名
    * @param nameList
    */
    public AppointmentConstraintQuery nameList(List<String> nameList){
        this.nameList = nameList;
		return this;
    }


	/**
    * 设置 联系方式
    * @param contact
    */
    public AppointmentConstraintQuery contact(String contact){
        setContact(contact);
		return this;
    }

    /**
    * 设置 联系方式
    * @param contactList
    */
    public AppointmentConstraintQuery contactList(List<String> contactList){
        this.contactList = contactList;
		return this;
    }


	/**
    * 设置 证件类型
    * @param idCardType
    */
    public AppointmentConstraintQuery idCardType(String idCardType){
        setIdCardType(idCardType);
		return this;
    }

    /**
    * 设置 证件类型
    * @param idCardTypeList
    */
    public AppointmentConstraintQuery idCardTypeList(List<String> idCardTypeList){
        this.idCardTypeList = idCardTypeList;
		return this;
    }


	/**
    * 设置 证件号码
    * @param idCardNo
    */
    public AppointmentConstraintQuery idCardNo(String idCardNo){
        setIdCardNo(idCardNo);
		return this;
    }

    /**
    * 设置 证件号码
    * @param idCardNoList
    */
    public AppointmentConstraintQuery idCardNoList(List<String> idCardNoList){
        this.idCardNoList = idCardNoList;
		return this;
    }

    /**
    * 设置  累计次数
    * @param accumulative
    */
    public AppointmentConstraintQuery accumulative(Long accumulative){
	    setAccumulative(accumulative);
		return this;
    }
	
	 /**
    * 设置 开始 累计次数
    * @param accumulativeStart
    */
    public AppointmentConstraintQuery accumulativeStart(Long accumulativeStart){
		this.accumulativeStart = accumulativeStart;
		return this;
    }

    /**
    * 设置 结束 累计次数
    * @param accumulativeEnd
    */
    public AppointmentConstraintQuery accumulativeEnd(Long accumulativeEnd){
		this.accumulativeEnd = accumulativeEnd;
		return this;
    }

    /**
    * 设置 增加 累计次数
    * @param accumulativeIncrement
    */
    public AppointmentConstraintQuery accumulativeIncrement(Long accumulativeIncrement){
		this.accumulativeIncrement = accumulativeIncrement;
		return this;
    }

    /**
    * 设置 累计次数
    * @param accumulativeList
    */
    public AppointmentConstraintQuery accumulativeList(List<Long> accumulativeList){
        this.accumulativeList = accumulativeList;
		return this;
        }

        /**
        * 设置 累计次数
        * @param accumulativeNotList
        */
        public AppointmentConstraintQuery accumulativeNotList(List<Long> accumulativeNotList){
        this.accumulativeNotList = accumulativeNotList;
        return this;
        }


    /**
    * 设置  创建方式(0.手动创建，1.系统推荐)
    * @param createMethod
    */
    public AppointmentConstraintQuery createMethod(Integer createMethod){
	    setCreateMethod(createMethod);
		return this;
    }
	
	 /**
    * 设置 开始 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodStart
    */
    public AppointmentConstraintQuery createMethodStart(Integer createMethodStart){
		this.createMethodStart = createMethodStart;
		return this;
    }

    /**
    * 设置 结束 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodEnd
    */
    public AppointmentConstraintQuery createMethodEnd(Integer createMethodEnd){
		this.createMethodEnd = createMethodEnd;
		return this;
    }

    /**
    * 设置 增加 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodIncrement
    */
    public AppointmentConstraintQuery createMethodIncrement(Integer createMethodIncrement){
		this.createMethodIncrement = createMethodIncrement;
		return this;
    }

    /**
    * 设置 创建方式(0.手动创建，1.系统推荐)
    * @param createMethodList
    */
    public AppointmentConstraintQuery createMethodList(List<Integer> createMethodList){
        this.createMethodList = createMethodList;
		return this;
        }

        /**
        * 设置 创建方式(0.手动创建，1.系统推荐)
        * @param createMethodNotList
        */
        public AppointmentConstraintQuery createMethodNotList(List<Integer> createMethodNotList){
        this.createMethodNotList = createMethodNotList;
        return this;
        }


	/**
    * 设置 操作人员
    * @param operator
    */
    public AppointmentConstraintQuery operator(String operator){
        setOperator(operator);
		return this;
    }

    /**
    * 设置 操作人员
    * @param operatorList
    */
    public AppointmentConstraintQuery operatorList(List<String> operatorList){
        this.operatorList = operatorList;
		return this;
    }

    /**
    * 设置  是否约束 (0.否，1.是)
    * @param constraint
    */
    public AppointmentConstraintQuery constraint(Integer constraint){
	    setConstraint(constraint);
		return this;
    }
	
	 /**
    * 设置 开始 是否约束 (0.否，1.是)
    * @param constraintStart
    */
    public AppointmentConstraintQuery constraintStart(Integer constraintStart){
		this.constraintStart = constraintStart;
		return this;
    }

    /**
    * 设置 结束 是否约束 (0.否，1.是)
    * @param constraintEnd
    */
    public AppointmentConstraintQuery constraintEnd(Integer constraintEnd){
		this.constraintEnd = constraintEnd;
		return this;
    }

    /**
    * 设置 增加 是否约束 (0.否，1.是)
    * @param constraintIncrement
    */
    public AppointmentConstraintQuery constraintIncrement(Integer constraintIncrement){
		this.constraintIncrement = constraintIncrement;
		return this;
    }

    /**
    * 设置 是否约束 (0.否，1.是)
    * @param constraintList
    */
    public AppointmentConstraintQuery constraintList(List<Integer> constraintList){
        this.constraintList = constraintList;
		return this;
        }

        /**
        * 设置 是否约束 (0.否，1.是)
        * @param constraintNotList
        */
        public AppointmentConstraintQuery constraintNotList(List<Integer> constraintNotList){
        this.constraintNotList = constraintNotList;
        return this;
        }


    /**
    * 设置  创建人ID
    * @param createUserId
    */
    public AppointmentConstraintQuery createUserId(Long createUserId){
	    setCreateUserId(createUserId);
		return this;
    }
	
	 /**
    * 设置 开始 创建人ID
    * @param createUserIdStart
    */
    public AppointmentConstraintQuery createUserIdStart(Long createUserIdStart){
		this.createUserIdStart = createUserIdStart;
		return this;
    }

    /**
    * 设置 结束 创建人ID
    * @param createUserIdEnd
    */
    public AppointmentConstraintQuery createUserIdEnd(Long createUserIdEnd){
		this.createUserIdEnd = createUserIdEnd;
		return this;
    }

    /**
    * 设置 增加 创建人ID
    * @param createUserIdIncrement
    */
    public AppointmentConstraintQuery createUserIdIncrement(Long createUserIdIncrement){
		this.createUserIdIncrement = createUserIdIncrement;
		return this;
    }

    /**
    * 设置 创建人ID
    * @param createUserIdList
    */
    public AppointmentConstraintQuery createUserIdList(List<Long> createUserIdList){
        this.createUserIdList = createUserIdList;
		return this;
        }

        /**
        * 设置 创建人ID
        * @param createUserIdNotList
        */
        public AppointmentConstraintQuery createUserIdNotList(List<Long> createUserIdNotList){
        this.createUserIdNotList = createUserIdNotList;
        return this;
        }


    /**
    * 设置  更新人ID
    * @param updateUserId
    */
    public AppointmentConstraintQuery updateUserId(Long updateUserId){
	    setUpdateUserId(updateUserId);
		return this;
    }
	
	 /**
    * 设置 开始 更新人ID
    * @param updateUserIdStart
    */
    public AppointmentConstraintQuery updateUserIdStart(Long updateUserIdStart){
		this.updateUserIdStart = updateUserIdStart;
		return this;
    }

    /**
    * 设置 结束 更新人ID
    * @param updateUserIdEnd
    */
    public AppointmentConstraintQuery updateUserIdEnd(Long updateUserIdEnd){
		this.updateUserIdEnd = updateUserIdEnd;
		return this;
    }

    /**
    * 设置 增加 更新人ID
    * @param updateUserIdIncrement
    */
    public AppointmentConstraintQuery updateUserIdIncrement(Long updateUserIdIncrement){
		this.updateUserIdIncrement = updateUserIdIncrement;
		return this;
    }

    /**
    * 设置 更新人ID
    * @param updateUserIdList
    */
    public AppointmentConstraintQuery updateUserIdList(List<Long> updateUserIdList){
        this.updateUserIdList = updateUserIdList;
		return this;
        }

        /**
        * 设置 更新人ID
        * @param updateUserIdNotList
        */
        public AppointmentConstraintQuery updateUserIdNotList(List<Long> updateUserIdNotList){
        this.updateUserIdNotList = updateUserIdNotList;
        return this;
        }

    /**
    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
    * @return orConditionList
    */
    public List<AppointmentConstraintQuery> getOrConditionList(){
    return this.orConditionList;
    }

    /**
    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
    * @param orConditionList
    */
    public void setOrConditionList(List<AppointmentConstraintQuery> orConditionList){
        this.orConditionList = orConditionList;
    }

    /**
    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
    * @return andConditionList
    */
    public List<AppointmentConstraintQuery> getAndConditionList(){
        return this.andConditionList;
    }

    /**
    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
    * @param andConditionList
    */
    public void setAndConditionList(List<AppointmentConstraintQuery> andConditionList){
        this.andConditionList = andConditionList;
    }

}