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

import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.license.model.LicenseEntity;
/**
 * 许可证查询对象
 *
 * @author zxfei
 * @date 2024-07-08
 */
public class LicenseQuery extends LicenseEntity {
    /** 开始 序号，主键，自增长 */
    private Long idStart;

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

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

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

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

    /** 私钥地址 */
    private List<String> licensePriPathList;

    /** 私钥地址排除列表 */
    private List <String> licensePriPathNotList;
    /** 公钥 */
    private List<String> licensePubPathList;

    /** 公钥排除列表 */
    private List <String> licensePubPathNotList;
    /** 许可证密钥或代码 */
    private List<String> licenseKeyPathList;

    /** 许可证密钥或代码排除列表 */
    private List <String> licenseKeyPathNotList;
    /** 许可证编码，如服务器mac地址 */
    private List<String> licenseCodeList;

    /** 许可证编码，如服务器mac地址排除列表 */
    private List <String> licenseCodeNotList;
    /** 开始 许可证颁发日期 */
    private String startTimeStart;

    /** 结束 许可证颁发日期 */
    private String startTimeEnd;

    /** 开始 许可证过期日期 */
    private String endTimeStart;

    /** 结束 许可证过期日期 */
    private String endTimeEnd;

    /** 许可证状态（有效,过期,暂停） */
    private List<String> licenseStatusList;

    /** 许可证状态（有效,过期,暂停）排除列表 */
    private List <String> licenseStatusNotList;
    /** 备注 */
    private List<String> remarkList;

    /** 备注排除列表 */
    private List <String> remarkNotList;
    /** 开始 创建用户 */
    private Long createUserIdStart;

    /** 结束 创建用户 */
    private Long createUserIdEnd;

    /** 增加 创建用户 */
    private Long createUserIdIncrement;

    /** 创建用户列表 */
    private List <Long> createUserIdList;

    /** 创建用户排除列表 */
    private List <Long> createUserIdNotList;

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

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

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

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

    /** 项目名称 */
    private List<String> nameList;

    /** 项目名称排除列表 */
    private List <String> nameNotList;
    /** 服务器mac地址 */
    private List<String> macList;

    /** 服务器mac地址排除列表 */
    private List <String> macNotList;
    /** ip地址 */
    private List<String> ipList;

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

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

    public LicenseQuery(){}

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

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

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

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

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

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

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

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

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

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


    /**
     * 获取 私钥地址
     * @return licensePriPathList
     */
    public List<String> getLicensePriPathList(){
        return this.licensePriPathList;
    }

    /**
     * 设置 私钥地址
     * @param licensePriPathList
     */
    public void setLicensePriPathList(List<String> licensePriPathList){
        this.licensePriPathList = licensePriPathList;
    }

    /**
     * 获取 私钥地址
     * @return licensePriPathNotList
     */
    public List<String> getLicensePriPathNotList(){
        return this.licensePriPathNotList;
    }

    /**
     * 设置 私钥地址
     * @param licensePriPathNotList
     */
    public void setLicensePriPathNotList(List<String> licensePriPathNotList){
        this.licensePriPathNotList = licensePriPathNotList;
    }

    /**
     * 获取 公钥
     * @return licensePubPathList
     */
    public List<String> getLicensePubPathList(){
        return this.licensePubPathList;
    }

    /**
     * 设置 公钥
     * @param licensePubPathList
     */
    public void setLicensePubPathList(List<String> licensePubPathList){
        this.licensePubPathList = licensePubPathList;
    }

    /**
     * 获取 公钥
     * @return licensePubPathNotList
     */
    public List<String> getLicensePubPathNotList(){
        return this.licensePubPathNotList;
    }

    /**
     * 设置 公钥
     * @param licensePubPathNotList
     */
    public void setLicensePubPathNotList(List<String> licensePubPathNotList){
        this.licensePubPathNotList = licensePubPathNotList;
    }

    /**
     * 获取 许可证密钥或代码
     * @return licenseKeyPathList
     */
    public List<String> getLicenseKeyPathList(){
        return this.licenseKeyPathList;
    }

    /**
     * 设置 许可证密钥或代码
     * @param licenseKeyPathList
     */
    public void setLicenseKeyPathList(List<String> licenseKeyPathList){
        this.licenseKeyPathList = licenseKeyPathList;
    }

    /**
     * 获取 许可证密钥或代码
     * @return licenseKeyPathNotList
     */
    public List<String> getLicenseKeyPathNotList(){
        return this.licenseKeyPathNotList;
    }

    /**
     * 设置 许可证密钥或代码
     * @param licenseKeyPathNotList
     */
    public void setLicenseKeyPathNotList(List<String> licenseKeyPathNotList){
        this.licenseKeyPathNotList = licenseKeyPathNotList;
    }

    /**
     * 获取 许可证编码，如服务器mac地址
     * @return licenseCodeList
     */
    public List<String> getLicenseCodeList(){
        return this.licenseCodeList;
    }

    /**
     * 设置 许可证编码，如服务器mac地址
     * @param licenseCodeList
     */
    public void setLicenseCodeList(List<String> licenseCodeList){
        this.licenseCodeList = licenseCodeList;
    }

    /**
     * 获取 许可证编码，如服务器mac地址
     * @return licenseCodeNotList
     */
    public List<String> getLicenseCodeNotList(){
        return this.licenseCodeNotList;
    }

    /**
     * 设置 许可证编码，如服务器mac地址
     * @param licenseCodeNotList
     */
    public void setLicenseCodeNotList(List<String> licenseCodeNotList){
        this.licenseCodeNotList = licenseCodeNotList;
    }

    /**
     * 获取 开始 许可证颁发日期
     * @return startTimeStart
     */
    public String getStartTimeStart(){
        return this.startTimeStart;
    }

    /**
     * 设置 开始 许可证颁发日期
     * @param startTimeStart
     */
    public void setStartTimeStart(String startTimeStart){
        this.startTimeStart = startTimeStart;
    }

    /**
     * 获取 结束 许可证颁发日期
     * @return startTimeEnd
     */
    public String getStartTimeEnd(){
        return this.startTimeEnd;
    }

    /**
     * 设置 结束 许可证颁发日期
     * @param startTimeEnd
     */
    public void setStartTimeEnd(String startTimeEnd){
        this.startTimeEnd = startTimeEnd;
    }

    /**
     * 获取 开始 许可证过期日期
     * @return endTimeStart
     */
    public String getEndTimeStart(){
        return this.endTimeStart;
    }

    /**
     * 设置 开始 许可证过期日期
     * @param endTimeStart
     */
    public void setEndTimeStart(String endTimeStart){
        this.endTimeStart = endTimeStart;
    }

    /**
     * 获取 结束 许可证过期日期
     * @return endTimeEnd
     */
    public String getEndTimeEnd(){
        return this.endTimeEnd;
    }

    /**
     * 设置 结束 许可证过期日期
     * @param endTimeEnd
     */
    public void setEndTimeEnd(String endTimeEnd){
        this.endTimeEnd = endTimeEnd;
    }

    /**
     * 获取 许可证状态（有效,过期,暂停）
     * @return licenseStatusList
     */
    public List<String> getLicenseStatusList(){
        return this.licenseStatusList;
    }

    /**
     * 设置 许可证状态（有效,过期,暂停）
     * @param licenseStatusList
     */
    public void setLicenseStatusList(List<String> licenseStatusList){
        this.licenseStatusList = licenseStatusList;
    }

    /**
     * 获取 许可证状态（有效,过期,暂停）
     * @return licenseStatusNotList
     */
    public List<String> getLicenseStatusNotList(){
        return this.licenseStatusNotList;
    }

    /**
     * 设置 许可证状态（有效,过期,暂停）
     * @param licenseStatusNotList
     */
    public void setLicenseStatusNotList(List<String> licenseStatusNotList){
        this.licenseStatusNotList = licenseStatusNotList;
    }

    /**
     * 获取 备注
     * @return remarkList
     */
    public List<String> getRemarkList(){
        return this.remarkList;
    }

    /**
     * 设置 备注
     * @param remarkList
     */
    public void setRemarkList(List<String> remarkList){
        this.remarkList = remarkList;
    }

    /**
     * 获取 备注
     * @return remarkNotList
     */
    public List<String> getRemarkNotList(){
        return this.remarkNotList;
    }

    /**
     * 设置 备注
     * @param remarkNotList
     */
    public void setRemarkNotList(List<String> remarkNotList){
        this.remarkNotList = remarkNotList;
    }

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

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

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

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

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

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

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

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

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

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


    /**
     * 获取 开始 创建时间
     * @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;
    }

    /**
     * 获取 开始 更新时间
     * @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;
    }

    /**
     * 获取 项目名称
     * @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;
    }

    /**
     * 获取 服务器mac地址
     * @return macList
     */
    public List<String> getMacList(){
        return this.macList;
    }

    /**
     * 设置 服务器mac地址
     * @param macList
     */
    public void setMacList(List<String> macList){
        this.macList = macList;
    }

    /**
     * 获取 服务器mac地址
     * @return macNotList
     */
    public List<String> getMacNotList(){
        return this.macNotList;
    }

    /**
     * 设置 服务器mac地址
     * @param macNotList
     */
    public void setMacNotList(List<String> macNotList){
        this.macNotList = macNotList;
    }

    /**
     * 获取 ip地址
     * @return ipList
     */
    public List<String> getIpList(){
        return this.ipList;
    }

    /**
     * 设置 ip地址
     * @param ipList
     */
    public void setIpList(List<String> ipList){
        this.ipList = ipList;
    }

    /**
     * 获取 ip地址
     * @return ipNotList
     */
    public List<String> getIpNotList(){
        return this.ipNotList;
    }

    /**
     * 设置 ip地址
     * @param ipNotList
     */
    public void setIpNotList(List<String> ipNotList){
        this.ipNotList = ipNotList;
    }

    /**
     * 设置  序号，主键，自增长
     * @param id
     */
    public LicenseQuery id(Long id){
        setId(id);
        return this;
    }

    /**
     * 设置 开始 序号，主键，自增长
     * @param idStart
     */
    public LicenseQuery idStart(Long idStart){
        this.idStart = idStart;
        return this;
    }

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

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

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

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


    /**
     * 设置 私钥地址
     * @param licensePriPath
     */
    public LicenseQuery licensePriPath(String licensePriPath){
        setLicensePriPath(licensePriPath);
        return this;
    }

    /**
     * 设置 私钥地址
     * @param licensePriPathList
     */
    public LicenseQuery licensePriPathList(List<String> licensePriPathList){
        this.licensePriPathList = licensePriPathList;
        return this;
    }


    /**
     * 设置 公钥
     * @param licensePubPath
     */
    public LicenseQuery licensePubPath(String licensePubPath){
        setLicensePubPath(licensePubPath);
        return this;
    }

    /**
     * 设置 公钥
     * @param licensePubPathList
     */
    public LicenseQuery licensePubPathList(List<String> licensePubPathList){
        this.licensePubPathList = licensePubPathList;
        return this;
    }


    /**
     * 设置 许可证密钥或代码
     * @param licenseKeyPath
     */
    public LicenseQuery licenseKeyPath(String licenseKeyPath){
        setLicenseKeyPath(licenseKeyPath);
        return this;
    }

    /**
     * 设置 许可证密钥或代码
     * @param licenseKeyPathList
     */
    public LicenseQuery licenseKeyPathList(List<String> licenseKeyPathList){
        this.licenseKeyPathList = licenseKeyPathList;
        return this;
    }


    /**
     * 设置 许可证编码，如服务器mac地址
     * @param licenseCode
     */
    public LicenseQuery licenseCode(String licenseCode){
        setLicenseCode(licenseCode);
        return this;
    }

    /**
     * 设置 许可证编码，如服务器mac地址
     * @param licenseCodeList
     */
    public LicenseQuery licenseCodeList(List<String> licenseCodeList){
        this.licenseCodeList = licenseCodeList;
        return this;
    }




    /**
     * 设置 许可证状态（有效,过期,暂停）
     * @param licenseStatus
     */
    public LicenseQuery licenseStatus(String licenseStatus){
        setLicenseStatus(licenseStatus);
        return this;
    }

    /**
     * 设置 许可证状态（有效,过期,暂停）
     * @param licenseStatusList
     */
    public LicenseQuery licenseStatusList(List<String> licenseStatusList){
        this.licenseStatusList = licenseStatusList;
        return this;
    }


    /**
     * 设置 备注
     * @param remark
     */
    public LicenseQuery remark(String remark){
        setRemark(remark);
        return this;
    }

    /**
     * 设置 备注
     * @param remarkList
     */
    public LicenseQuery remarkList(List<String> remarkList){
        this.remarkList = remarkList;
        return this;
    }

    /**
     * 设置  创建用户
     * @param createUserId
     */
    public LicenseQuery createUserId(Long createUserId){
        setCreateUserId(createUserId);
        return this;
    }

    /**
     * 设置 开始 创建用户
     * @param createUserIdStart
     */
    public LicenseQuery createUserIdStart(Long createUserIdStart){
        this.createUserIdStart = createUserIdStart;
        return this;
    }

    /**
     * 设置 结束 创建用户
     * @param createUserIdEnd
     */
    public LicenseQuery createUserIdEnd(Long createUserIdEnd){
        this.createUserIdEnd = createUserIdEnd;
        return this;
    }

    /**
     * 设置 增加 创建用户
     * @param createUserIdIncrement
     */
    public LicenseQuery createUserIdIncrement(Long createUserIdIncrement){
        this.createUserIdIncrement = createUserIdIncrement;
        return this;
    }

    /**
     * 设置 创建用户
     * @param createUserIdList
     */
    public LicenseQuery createUserIdList(List<Long> createUserIdList){
        this.createUserIdList = createUserIdList;
        return this;
    }

    /**
     * 设置 创建用户
     * @param createUserIdNotList
     */
    public LicenseQuery createUserIdNotList(List<Long> createUserIdNotList){
        this.createUserIdNotList = createUserIdNotList;
        return this;
    }




    /**
     * 设置 项目名称
     * @param name
     */
    public LicenseQuery name(String name){
        setName(name);
        return this;
    }

    /**
     * 设置 项目名称
     * @param nameList
     */
    public LicenseQuery nameList(List<String> nameList){
        this.nameList = nameList;
        return this;
    }


    /**
     * 设置 服务器mac地址
     * @param mac
     */
    public LicenseQuery mac(String mac){
        setMac(mac);
        return this;
    }

    /**
     * 设置 服务器mac地址
     * @param macList
     */
    public LicenseQuery macList(List<String> macList){
        this.macList = macList;
        return this;
    }


    /**
     * 设置 ip地址
     * @param ip
     */
    public LicenseQuery ip(String ip){
        setIp(ip);
        return this;
    }

    /**
     * 设置 ip地址
     * @param ipList
     */
    public LicenseQuery ipList(List<String> ipList){
        this.ipList = ipList;
        return this;
    }

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

}