pzobk9anl
/
fresh
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

122

Browse Source
pull/3/head
wzw 1 month ago
parent a3e66a7a04
commit 04ff3da94d
16 changed files with 1076 additions and 189 deletions
Show Stats Download Patch File Download Diff File

91
src/main/java/com/xmomen/module/base/entity/CdBindExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 绑定信息示例类
public class CdBindExample extends BaseMybatisExample {
// 排序字段
protected String orderByClause;
// 是否去重
protected boolean distinct;
// 查询条件
protected List<Criteria> oredCriteria;
// 构造函数
public CdBindExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置排序字段
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取排序字段
public String getOrderByClause() {
return orderByClause;
}
// 设置是否去重
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取是否去重
public boolean isDistinct() {
return distinct;
}
// 获取查询条件
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -53,37 +66,46 @@ public class CdBindExample extends BaseMybatisExample {
return criteria;
}
// 创建查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空查询条件
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 生成查询条件
protected abstract static class GeneratedCriteria {
// 查询条件列表
protected List<Criterion> criteria;
// 构造函数
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
// 判断查询条件是否有效
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -91,6 +113,7 @@ public class CdBindExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -98,6 +121,7 @@ public class CdBindExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -105,267 +129,320 @@ public class CdBindExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 添加ID为空的查询条件
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 添加ID不为空的查询条件
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 添加ID等于指定值的查询条件
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 添加ID不等于指定值的查询条件
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 添加ID大于指定值的查询条件
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 添加ID大于等于指定值的查询条件
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 添加ID小于指定值的查询条件
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 添加ID小于等于指定值的查询条件
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 添加ID在指定值列表中的查询条件
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 添加ID不在指定值列表中的查询条件
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 添加ID在指定值之间的查询条件
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 添加ID不在指定值之间的查询条件
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 添加用户ID为空的查询条件
public Criteria andUserIdIsNull() {
addCriterion("user_id is null");
return (Criteria) this;
}
// 添加用户ID不为空的查询条件
public Criteria andUserIdIsNotNull() {
addCriterion("user_id is not null");
return (Criteria) this;
}
// 添加用户ID等于指定值的查询条件
public Criteria andUserIdEqualTo(Integer value) {
addCriterion("user_id =", value, "userId");
return (Criteria) this;
}
// 添加用户ID不等于指定值的查询条件
public Criteria andUserIdNotEqualTo(Integer value) {
addCriterion("user_id <>", value, "userId");
return (Criteria) this;
}
// 添加用户ID大于指定值的查询条件
public Criteria andUserIdGreaterThan(Integer value) {
addCriterion("user_id >", value, "userId");
return (Criteria) this;
}
// 添加用户ID大于等于指定值的查询条件
public Criteria andUserIdGreaterThanOrEqualTo(Integer value) {
addCriterion("user_id >=", value, "userId");
return (Criteria) this;
}
// 添加用户ID小于指定值的查询条件
public Criteria andUserIdLessThan(Integer value) {
addCriterion("user_id <", value, "userId");
return (Criteria) this;
}
// 添加用户ID小于等于指定值的查询条件
public Criteria andUserIdLessThanOrEqualTo(Integer value) {
addCriterion("user_id <=", value, "userId");
return (Criteria) this;
}
// 添加用户ID在指定值列表中的查询条件
public Criteria andUserIdIn(List<Integer> values) {
addCriterion("user_id in", values, "userId");
return (Criteria) this;
}
// 添加用户ID不在指定值列表中的查询条件
public Criteria andUserIdNotIn(List<Integer> values) {
addCriterion("user_id not in", values, "userId");
return (Criteria) this;
}
// 添加用户ID在指定值之间的查询条件
public Criteria andUserIdBetween(Integer value1, Integer value2) {
addCriterion("user_id between", value1, value2, "userId");
return (Criteria) this;
}
// 添加用户ID不在指定值之间的查询条件
public Criteria andUserIdNotBetween(Integer value1, Integer value2) {
addCriterion("user_id not between", value1, value2, "userId");
return (Criteria) this;
}
// 添加手机号为空的查询条件
public Criteria andPhoneIsNull() {
addCriterion("PHONE is null");
return (Criteria) this;
}
// 添加手机号不为空的查询条件
public Criteria andPhoneIsNotNull() {
addCriterion("PHONE is not null");
return (Criteria) this;
}
// 添加手机号等于指定值的查询条件
public Criteria andPhoneEqualTo(String value) {
addCriterion("PHONE =", value, "phone");
return (Criteria) this;
}
// 添加手机号不等于指定值的查询条件
public Criteria andPhoneNotEqualTo(String value) {
addCriterion("PHONE <>", value, "phone");
return (Criteria) this;
}
// 添加手机号大于指定值的查询条件
public Criteria andPhoneGreaterThan(String value) {
addCriterion("PHONE >", value, "phone");
return (Criteria) this;
}
// 添加手机号大于等于指定值的查询条件
public Criteria andPhoneGreaterThanOrEqualTo(String value) {
addCriterion("PHONE >=", value, "phone");
return (Criteria) this;
}
// 添加手机号小于指定值的查询条件
public Criteria andPhoneLessThan(String value) {
addCriterion("PHONE <", value, "phone");
return (Criteria) this;
}
// 添加手机号小于等于指定值的查询条件
public Criteria andPhoneLessThanOrEqualTo(String value) {
addCriterion("PHONE <=", value, "phone");
return (Criteria) this;
}
// 添加手机号包含指定值的查询条件
public Criteria andPhoneLike(String value) {
addCriterion("PHONE like", value, "phone");
return (Criteria) this;
}
// 添加手机号不包含指定值的查询条件
public Criteria andPhoneNotLike(String value) {
addCriterion("PHONE not like", value, "phone");
return (Criteria) this;
}
// 添加手机号在指定值列表中的查询条件
public Criteria andPhoneIn(List<String> values) {
addCriterion("PHONE in", values, "phone");
return (Criteria) this;
}
// 添加手机号不在指定值列表中的查询条件
public Criteria andPhoneNotIn(List<String> values) {
addCriterion("PHONE not in", values, "phone");
return (Criteria) this;
}
// 添加手机号在指定值之间的查询条件
public Criteria andPhoneBetween(String value1, String value2) {
addCriterion("PHONE between", value1, value2, "phone");
return (Criteria) this;
}
// 添加手机号不在指定值之间的查询条件
public Criteria andPhoneNotBetween(String value1, String value2) {
addCriterion("PHONE not between", value1, value2, "phone");
return (Criteria) this;
}
// 添加OpenID为空的查询条件
public Criteria andOpenIdIsNull() {
addCriterion("OPEN_ID is null");
return (Criteria) this;
}
// 添加OpenID不为空的查询条件
public Criteria andOpenIdIsNotNull() {
addCriterion("OPEN_ID is not null");
return (Criteria) this;
}
// 添加OpenID等于指定值的查询条件
public Criteria andOpenIdEqualTo(String value) {
addCriterion("OPEN_ID =", value, "openId");
return (Criteria) this;
}
// 添加OpenID不等于指定值的查询条件
public Criteria andOpenIdNotEqualTo(String value) {
addCriterion("OPEN_ID <>", value, "openId");
return (Criteria) this;
}
// 添加OpenID大于指定值的查询条件
public Criteria andOpenIdGreaterThan(String value) {
addCriterion("OPEN_ID >", value, "openId");
return (Criteria) this;
}
// 添加OpenID大于等于指定值的查询条件
public Criteria andOpenIdGreaterThanOrEqualTo(String value) {
addCriterion("OPEN_ID >=", value, "openId");
return (Criteria) this;
}
// 添加OpenID小于指定值的查询条件
public Criteria andOpenIdLessThan(String value) {
addCriterion("OPEN_ID <", value, "openId");
return (Criteria) this;
}
// 添加OpenID小于等于指定值的查询条件
public Criteria andOpenIdLessThanOrEqualTo(String value) {
addCriterion("OPEN_ID <=", value, "openId");
return (Criteria) this;
}
// 添加OpenID包含指定值的查询条件
public Criteria andOpenIdLike(String value) {
addCriterion("OPEN_ID like", value, "openId");
return (Criteria) this;
}
// 添加OpenID不包含指定值的查询条件
public Criteria andOpenIdNotLike(String value) {
addCriterion("OPEN_ID not like", value, "openId");
return (Criteria) this;
}
// 添加OpenID在指定值列表中的查询条件
public Criteria andOpenIdIn(List<String> values) {
addCriterion("OPEN_ID in", values, "openId");
return (Criteria) this;
}
// 添加OpenID不在指定值列表中的查询条件
public Criteria andOpenIdNotIn(List<String> values) {
addCriterion("OPEN_ID not in", values, "openId");
return (Criteria) this;
}
// 添加OpenID在指定值之间的查询条件
public Criteria andOpenIdBetween(String value1, String value2) {
addCriterion("OPEN_ID between", value1, value2, "openId");
return (Criteria) this;
}
// 添加OpenID不在指定值之间的查询条件
public Criteria andOpenIdNotBetween(String value1, String value2) {
addCriterion("OPEN_ID not between", value1, value2, "openId");
return (Criteria) this;
}
}
// 查询条件
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
@ -373,6 +450,7 @@ public class CdBindExample extends BaseMybatisExample {
}
}
// 查询条件
public static class Criterion {
private String condition;
@ -390,38 +468,47 @@ public class CdBindExample extends BaseMybatisExample {
private String typeHandler;
// 获取查询条件
public String getCondition() {
return condition;
}
// 获取查询条件的值
public Object getValue() {
return value;
}
// 获取查询条件的第二个值
public Object getSecondValue() {
return secondValue;
}
// 判断查询条件是否为空
public boolean isNoValue() {
return noValue;
}
// 判断查询条件是否为单个值
public boolean isSingleValue() {
return singleValue;
}
// 判断查询条件是否为范围值
public boolean isBetweenValue() {
return betweenValue;
}
// 判断查询条件是否为列表值
public boolean isListValue() {
return listValue;
}
// 获取查询条件的类型处理器
public String getTypeHandler() {
return typeHandler;
}
// 构造函数
protected Criterion(String condition) {
super();
this.condition = condition;
@ -429,6 +516,7 @@ public class CdBindExample extends BaseMybatisExample {
this.noValue = true;
}
// 构造函数
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
@ -441,10 +529,12 @@ public class CdBindExample extends BaseMybatisExample {
}
}
// 构造函数
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
// 构造函数
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
@ -454,6 +544,7 @@ public class CdBindExample extends BaseMybatisExample {
this.betweenValue = true;
}
// 构造函数
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

13
src/main/java/com/xmomen/module/base/entity/CdCategory.java
Unescape View File

@ -11,19 +11,14 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_category")
public class CdCategory extends BaseMybatisModel {
/**
*
*/
// 类别ID
private Integer id;
/**
* 类别名称
*/
// 类别名称
private String categoryName;
/**
* 上级类别
*/
// 父类别ID
private Integer parentId;
@Column(name = "ID")

77
src/main/java/com/xmomen/module/base/entity/CdCategoryExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 定义一个CdCategoryExample类，继承自BaseMybatisExample类
public class CdCategoryExample extends BaseMybatisExample {
// 定义一个orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量，用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria变量
public CdCategoryExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置orderByClause变量的值
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取orderByClause变量的值
public String getOrderByClause() {
return orderByClause;
}
// 设置distinct变量的值
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取distinct变量的值
public boolean isDistinct() {
return distinct;
}
// 获取oredCriteria变量的值
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加一个查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个新的查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -53,37 +66,46 @@ public class CdCategoryExample extends BaseMybatisExample {
return criteria;
}
// 创建一个新的查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空oredCriteria变量和orderByClause变量和distinct变量的值
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 定义一个GeneratedCriteria内部类，用于存储查询条件
protected abstract static class GeneratedCriteria {
// 定义一个criteria变量，用于存储查询条件
protected List<Criterion> criteria;
// 构造函数，初始化criteria变量
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
// 判断是否有查询条件
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有的查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加一个查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -91,6 +113,7 @@ public class CdCategoryExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -98,6 +121,7 @@ public class CdCategoryExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -105,197 +129,236 @@ public class CdCategoryExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 判断ID是否为空
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 判断ID是否不为空
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 判断ID是否等于某个值
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 判断ID是否不等于某个值
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 判断ID是否大于某个值
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 判断ID是否大于等于某个值
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 判断ID是否小于某个值
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 判断ID是否小于等于某个值
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否为空
public Criteria andCategoryNameIsNull() {
addCriterion("CATEGORY_NAME is null");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否不为空
public Criteria andCategoryNameIsNotNull() {
addCriterion("CATEGORY_NAME is not null");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否等于某个值
public Criteria andCategoryNameEqualTo(String value) {
addCriterion("CATEGORY_NAME =", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否不等于某个值
public Criteria andCategoryNameNotEqualTo(String value) {
addCriterion("CATEGORY_NAME <>", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否大于某个值
public Criteria andCategoryNameGreaterThan(String value) {
addCriterion("CATEGORY_NAME >", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否大于等于某个值
public Criteria andCategoryNameGreaterThanOrEqualTo(String value) {
addCriterion("CATEGORY_NAME >=", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否小于某个值
public Criteria andCategoryNameLessThan(String value) {
addCriterion("CATEGORY_NAME <", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否小于等于某个值
public Criteria andCategoryNameLessThanOrEqualTo(String value) {
addCriterion("CATEGORY_NAME <=", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否包含某个值
public Criteria andCategoryNameLike(String value) {
addCriterion("CATEGORY_NAME like", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否不包含某个值
public Criteria andCategoryNameNotLike(String value) {
addCriterion("CATEGORY_NAME not like", value, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否在某个范围内
public Criteria andCategoryNameIn(List<String> values) {
addCriterion("CATEGORY_NAME in", values, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否不在某个范围内
public Criteria andCategoryNameNotIn(List<String> values) {
addCriterion("CATEGORY_NAME not in", values, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否在某个范围内
public Criteria andCategoryNameBetween(String value1, String value2) {
addCriterion("CATEGORY_NAME between", value1, value2, "categoryName");
return (Criteria) this;
}
// 判断CATEGORY_NAME是否不在某个范围内
public Criteria andCategoryNameNotBetween(String value1, String value2) {
addCriterion("CATEGORY_NAME not between", value1, value2, "categoryName");
return (Criteria) this;
}
// 判断PARENT_ID是否为空
public Criteria andParentIdIsNull() {
addCriterion("PARENT_ID is null");
return (Criteria) this;
}
// 判断PARENT_ID是否不为空
public Criteria andParentIdIsNotNull() {
addCriterion("PARENT_ID is not null");
return (Criteria) this;
}
// 判断PARENT_ID是否等于某个值
public Criteria andParentIdEqualTo(Integer value) {
addCriterion("PARENT_ID =", value, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否不等于某个值
public Criteria andParentIdNotEqualTo(Integer value) {
addCriterion("PARENT_ID <>", value, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否大于某个值
public Criteria andParentIdGreaterThan(Integer value) {
addCriterion("PARENT_ID >", value, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否大于等于某个值
public Criteria andParentIdGreaterThanOrEqualTo(Integer value) {
addCriterion("PARENT_ID >=", value, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否小于某个值
public Criteria andParentIdLessThan(Integer value) {
addCriterion("PARENT_ID <", value, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否小于等于某个值
public Criteria andParentIdLessThanOrEqualTo(Integer value) {
addCriterion("PARENT_ID <=", value, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否在某个范围内
public Criteria andParentIdIn(List<Integer> values) {
addCriterion("PARENT_ID in", values, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否不在某个范围内
public Criteria andParentIdNotIn(List<Integer> values) {
addCriterion("PARENT_ID not in", values, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否在某个范围内
public Criteria andParentIdBetween(Integer value1, Integer value2) {
addCriterion("PARENT_ID between", value1, value2, "parentId");
return (Criteria) this;
}
// 判断PARENT_ID是否不在某个范围内
public Criteria andParentIdNotBetween(Integer value1, Integer value2) {
addCriterion("PARENT_ID not between", value1, value2, "parentId");
return (Criteria) this;
}
}
// 定义一个Criteria内部类，继承自GeneratedCriteria类
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
@ -303,6 +366,7 @@ public class CdCategoryExample extends BaseMybatisExample {
}
}
// 定义一个Criterion内部类，用于存储查询条件
public static class Criterion {
private String condition;
@ -320,38 +384,47 @@ public class CdCategoryExample extends BaseMybatisExample {
private String typeHandler;
// 获取condition变量的值
public String getCondition() {
return condition;
}
// 获取value变量的值
public Object getValue() {
return value;
}
// 获取secondValue变量的值
public Object getSecondValue() {
return secondValue;
}
// 判断是否没有值
public boolean isNoValue() {
return noValue;
}
// 判断是否只有一个值
public boolean isSingleValue() {
return singleValue;
}
// 判断是否在某个范围内
public boolean isBetweenValue() {
return betweenValue;
}
// 判断是否在某个范围内
public boolean isListValue() {
return listValue;
}
// 获取typeHandler变量的值
public String getTypeHandler() {
return typeHandler;
}
// 构造函数，初始化condition变量和typeHandler变量和noValue变量
protected Criterion(String condition) {
super();
this.condition = condition;
@ -359,6 +432,7 @@ public class CdCategoryExample extends BaseMybatisExample {
this.noValue = true;
}
// 构造函数，初始化condition变量和value变量和typeHandler变量和singleValue变量
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
@ -371,10 +445,12 @@ public class CdCategoryExample extends BaseMybatisExample {
}
}
// 构造函数，初始化condition变量和value变量和singleValue变量
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
// 构造函数，初始化condition变量和value变量和secondValue变量和typeHandler变量和betweenValue变量
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
@ -384,6 +460,7 @@ public class CdCategoryExample extends BaseMybatisExample {
this.betweenValue = true;
}
// 构造函数，初始化condition变量和value变量和secondValue变量和betweenValue变量
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

25
src/main/java/com/xmomen/module/base/entity/CdCompany.java
Unescape View File

@ -11,34 +11,23 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_company")
public class CdCompany extends BaseMybatisModel {
/**
*
*/
// 公司ID
private Integer id;
/**
* 单位编号
*/
// 公司编码
private String companyCode;
/**
* 单位名称
*/
// 公司名称
private String companyName;
/**
* 单位地址
*/
// 公司地址
private String companyAddress;
/**
* 单位联系人
*/
// 公司负责人
private String companyLeader;
/**
* 联系人电话
*/
// 公司负责人电话
private String companyLeaderTel;
@Column(name = "ID")

106
src/main/java/com/xmomen/module/base/entity/CdCompanyExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 定义一个CdCompanyExample类，继承自BaseMybatisExample类
public class CdCompanyExample extends BaseMybatisExample {
// 定义一个orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量，用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria变量
public CdCompanyExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置orderByClause变量的值
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取orderByClause变量的值
public String getOrderByClause() {
return orderByClause;
}
// 设置distinct变量的值
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取distinct变量的值
public boolean isDistinct() {
return distinct;
}
// 获取oredCriteria变量的值
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加一个查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个新的查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -53,37 +66,46 @@ public class CdCompanyExample extends BaseMybatisExample {
return criteria;
}
// 创建一个新的查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空oredCriteria变量和orderByClause变量和distinct变量的值
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 定义一个GeneratedCriteria类，用于存储查询条件
protected abstract static class GeneratedCriteria {
// 定义一个criteria变量，用于存储查询条件
protected List<Criterion> criteria;
// 构造函数，初始化criteria变量
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
// 判断是否有查询条件
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有的查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加一个查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -91,6 +113,7 @@ public class CdCompanyExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -98,6 +121,7 @@ public class CdCompanyExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -105,411 +129,493 @@ public class CdCompanyExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 判断ID是否为空
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 判断ID是否不为空
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 判断ID是否等于某个值
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 判断ID是否不等于某个值
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 判断ID是否大于某个值
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 判断ID是否大于等于某个值
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 判断ID是否小于某个值
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 判断ID是否小于等于某个值
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 判断COMPANY_CODE是否为空
public Criteria andCompanyCodeIsNull() {
addCriterion("COMPANY_CODE is null");
return (Criteria) this;
}
// 判断COMPANY_CODE是否不为空
public Criteria andCompanyCodeIsNotNull() {
addCriterion("COMPANY_CODE is not null");
return (Criteria) this;
}
// 判断COMPANY_CODE是否等于某个值
public Criteria andCompanyCodeEqualTo(String value) {
addCriterion("COMPANY_CODE =", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否不等于某个值
public Criteria andCompanyCodeNotEqualTo(String value) {
addCriterion("COMPANY_CODE <>", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否大于某个值
public Criteria andCompanyCodeGreaterThan(String value) {
addCriterion("COMPANY_CODE >", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否大于等于某个值
public Criteria andCompanyCodeGreaterThanOrEqualTo(String value) {
addCriterion("COMPANY_CODE >=", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否小于某个值
public Criteria andCompanyCodeLessThan(String value) {
addCriterion("COMPANY_CODE <", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否小于等于某个值
public Criteria andCompanyCodeLessThanOrEqualTo(String value) {
addCriterion("COMPANY_CODE <=", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否包含某个值
public Criteria andCompanyCodeLike(String value) {
addCriterion("COMPANY_CODE like", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否不包含某个值
public Criteria andCompanyCodeNotLike(String value) {
addCriterion("COMPANY_CODE not like", value, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否在某个范围内
public Criteria andCompanyCodeIn(List<String> values) {
addCriterion("COMPANY_CODE in", values, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否不在某个范围内
public Criteria andCompanyCodeNotIn(List<String> values) {
addCriterion("COMPANY_CODE not in", values, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否在某个范围内
public Criteria andCompanyCodeBetween(String value1, String value2) {
addCriterion("COMPANY_CODE between", value1, value2, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_CODE是否不在某个范围内
public Criteria andCompanyCodeNotBetween(String value1, String value2) {
addCriterion("COMPANY_CODE not between", value1, value2, "companyCode");
return (Criteria) this;
}
// 判断COMPANY_NAME是否为空
public Criteria andCompanyNameIsNull() {
addCriterion("COMPANY_NAME is null");
return (Criteria) this;
}
// 判断COMPANY_NAME是否不为空
public Criteria andCompanyNameIsNotNull() {
addCriterion("COMPANY_NAME is not null");
return (Criteria) this;
}
// 判断COMPANY_NAME是否等于某个值
public Criteria andCompanyNameEqualTo(String value) {
addCriterion("COMPANY_NAME =", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否不等于某个值
public Criteria andCompanyNameNotEqualTo(String value) {
addCriterion("COMPANY_NAME <>", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否大于某个值
public Criteria andCompanyNameGreaterThan(String value) {
addCriterion("COMPANY_NAME >", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否大于等于某个值
public Criteria andCompanyNameGreaterThanOrEqualTo(String value) {
addCriterion("COMPANY_NAME >=", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否小于某个值
public Criteria andCompanyNameLessThan(String value) {
addCriterion("COMPANY_NAME <", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否小于等于某个值
public Criteria andCompanyNameLessThanOrEqualTo(String value) {
addCriterion("COMPANY_NAME <=", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否包含某个值
public Criteria andCompanyNameLike(String value) {
addCriterion("COMPANY_NAME like", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否不包含某个值
public Criteria andCompanyNameNotLike(String value) {
addCriterion("COMPANY_NAME not like", value, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否在某个范围内
public Criteria andCompanyNameIn(List<String> values) {
addCriterion("COMPANY_NAME in", values, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否不在某个范围内
public Criteria andCompanyNameNotIn(List<String> values) {
addCriterion("COMPANY_NAME not in", values, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否在某个范围内
public Criteria andCompanyNameBetween(String value1, String value2) {
addCriterion("COMPANY_NAME between", value1, value2, "companyName");
return (Criteria) this;
}
// 判断COMPANY_NAME是否不在某个范围内
public Criteria andCompanyNameNotBetween(String value1, String value2) {
addCriterion("COMPANY_NAME not between", value1, value2, "companyName");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否为空
public Criteria andCompanyAddressIsNull() {
addCriterion("COMPANY_ADDRESS is null");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否不为空
public Criteria andCompanyAddressIsNotNull() {
addCriterion("COMPANY_ADDRESS is not null");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否等于某个值
public Criteria andCompanyAddressEqualTo(String value) {
addCriterion("COMPANY_ADDRESS =", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否不等于某个值
public Criteria andCompanyAddressNotEqualTo(String value) {
addCriterion("COMPANY_ADDRESS <>", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否大于某个值
public Criteria andCompanyAddressGreaterThan(String value) {
addCriterion("COMPANY_ADDRESS >", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否大于等于某个值
public Criteria andCompanyAddressGreaterThanOrEqualTo(String value) {
addCriterion("COMPANY_ADDRESS >=", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否小于某个值
public Criteria andCompanyAddressLessThan(String value) {
addCriterion("COMPANY_ADDRESS <", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否小于等于某个值
public Criteria andCompanyAddressLessThanOrEqualTo(String value) {
addCriterion("COMPANY_ADDRESS <=", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否包含某个值
public Criteria andCompanyAddressLike(String value) {
addCriterion("COMPANY_ADDRESS like", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否不包含某个值
public Criteria andCompanyAddressNotLike(String value) {
addCriterion("COMPANY_ADDRESS not like", value, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否在某个范围内
public Criteria andCompanyAddressIn(List<String> values) {
addCriterion("COMPANY_ADDRESS in", values, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否不在某个范围内
public Criteria andCompanyAddressNotIn(List<String> values) {
addCriterion("COMPANY_ADDRESS not in", values, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否在某个范围内
public Criteria andCompanyAddressBetween(String value1, String value2) {
addCriterion("COMPANY_ADDRESS between", value1, value2, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_ADDRESS是否不在某个范围内
public Criteria andCompanyAddressNotBetween(String value1, String value2) {
addCriterion("COMPANY_ADDRESS not between", value1, value2, "companyAddress");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否为空
public Criteria andCompanyLeaderIsNull() {
addCriterion("COMPANY_LEADER is null");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否不为空
public Criteria andCompanyLeaderIsNotNull() {
addCriterion("COMPANY_LEADER is not null");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否等于某个值
public Criteria andCompanyLeaderEqualTo(String value) {
addCriterion("COMPANY_LEADER =", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否不等于某个值
public Criteria andCompanyLeaderNotEqualTo(String value) {
addCriterion("COMPANY_LEADER <>", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否大于某个值
public Criteria andCompanyLeaderGreaterThan(String value) {
addCriterion("COMPANY_LEADER >", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否大于等于某个值
public Criteria andCompanyLeaderGreaterThanOrEqualTo(String value) {
addCriterion("COMPANY_LEADER >=", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否小于某个值
public Criteria andCompanyLeaderLessThan(String value) {
addCriterion("COMPANY_LEADER <", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否小于等于某个值
public Criteria andCompanyLeaderLessThanOrEqualTo(String value) {
addCriterion("COMPANY_LEADER <=", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否包含某个值
public Criteria andCompanyLeaderLike(String value) {
addCriterion("COMPANY_LEADER like", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否不包含某个值
public Criteria andCompanyLeaderNotLike(String value) {
addCriterion("COMPANY_LEADER not like", value, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否在某个范围内
public Criteria andCompanyLeaderIn(List<String> values) {
addCriterion("COMPANY_LEADER in", values, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否不在某个范围内
public Criteria andCompanyLeaderNotIn(List<String> values) {
addCriterion("COMPANY_LEADER not in", values, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否在某个范围内
public Criteria andCompanyLeaderBetween(String value1, String value2) {
addCriterion("COMPANY_LEADER between", value1, value2, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER是否不在某个范围内
public Criteria andCompanyLeaderNotBetween(String value1, String value2) {
addCriterion("COMPANY_LEADER not between", value1, value2, "companyLeader");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否为空
public Criteria andCompanyLeaderTelIsNull() {
addCriterion("COMPANY_LEADER_TEL is null");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否不为空
public Criteria andCompanyLeaderTelIsNotNull() {
addCriterion("COMPANY_LEADER_TEL is not null");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否等于某个值
public Criteria andCompanyLeaderTelEqualTo(String value) {
addCriterion("COMPANY_LEADER_TEL =", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否不等于某个值
public Criteria andCompanyLeaderTelNotEqualTo(String value) {
addCriterion("COMPANY_LEADER_TEL <>", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否大于某个值
public Criteria andCompanyLeaderTelGreaterThan(String value) {
addCriterion("COMPANY_LEADER_TEL >", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否大于等于某个值
public Criteria andCompanyLeaderTelGreaterThanOrEqualTo(String value) {
addCriterion("COMPANY_LEADER_TEL >=", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否小于某个值
public Criteria andCompanyLeaderTelLessThan(String value) {
addCriterion("COMPANY_LEADER_TEL <", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否小于等于某个值
public Criteria andCompanyLeaderTelLessThanOrEqualTo(String value) {
addCriterion("COMPANY_LEADER_TEL <=", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否包含某个值
public Criteria andCompanyLeaderTelLike(String value) {
addCriterion("COMPANY_LEADER_TEL like", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否不包含某个值
public Criteria andCompanyLeaderTelNotLike(String value) {
addCriterion("COMPANY_LEADER_TEL not like", value, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否在某个范围内
public Criteria andCompanyLeaderTelIn(List<String> values) {
addCriterion("COMPANY_LEADER_TEL in", values, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否不在某个范围内
public Criteria andCompanyLeaderTelNotIn(List<String> values) {
addCriterion("COMPANY_LEADER_TEL not in", values, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否在某个范围内
public Criteria andCompanyLeaderTelBetween(String value1, String value2) {
addCriterion("COMPANY_LEADER_TEL between", value1, value2, "companyLeaderTel");
return (Criteria) this;
}
// 判断COMPANY_LEADER_TEL是否不在某个范围内
public Criteria andCompanyLeaderTelNotBetween(String value1, String value2) {
addCriterion("COMPANY_LEADER_TEL not between", value1, value2, "companyLeaderTel");
return (Criteria) this;

45
src/main/java/com/xmomen/module/base/entity/CdContract.java
Unescape View File

@ -13,59 +13,38 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_contract")
public class CdContract extends BaseMybatisModel {
/**
*
*/
// 合同ID
private Integer id;
/**
* 合同编号
*/
// 合同编号
private String contractCode;
/**
* 合同名称
*/
// 合同名称
private String contractName;
/**
* 合同价的客户
*/
// 成员ID
private Integer cdMemberId;
/**
* 合同价的单位
*/
// 公司ID
private Integer cdCompanyId;
/**
* 1-部分产品，2-全部产品
*/
// 范围
private Integer scope;
/**
* 仅当适用范围为全部产品时适用
*/
// 合同价格
private BigDecimal contractPrice;
/**
* 合同开始时间
*/
// 开始时间
private Date beginTime;
/**
* 合同结束时间
*/
// 结束时间
private Date endTime;
/**
* 0-未作废，1-作废
*/
// 是否删除
private Integer isDel;
/**
* 0-未审核，1-审核
*/
// 是否审核
private Integer isAuditor;
@Column(name = "ID")

160
src/main/java/com/xmomen/module/base/entity/CdContractExample.java
Unescape View File

@ -6,47 +6,60 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
// 定义一个名为CdContractExample的类，继承自BaseMybatisExample
public class CdContractExample extends BaseMybatisExample {
// 定义一个orderByClause变量，用于存储排序字段
protected String orderByClause;
// 定义一个distinct变量，用于存储是否去重
protected boolean distinct;
// 定义一个oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria
public CdContractExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置orderByClause的值
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取orderByClause的值
public String getOrderByClause() {
return orderByClause;
}
// 设置distinct的值
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取distinct的值
public boolean isDistinct() {
return distinct;
}
// 获取oredCriteria的值
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个新的查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -55,37 +68,46 @@ public class CdContractExample extends BaseMybatisExample {
return criteria;
}
// 创建一个新的查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空查询条件
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 定义一个内部类GeneratedCriteria，用于存储查询条件
protected abstract static class GeneratedCriteria {
// 定义一个criteria变量，用于存储查询条件
protected List<Criterion> criteria;
// 构造函数，初始化criteria
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
// 判断查询条件是否有效
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -93,6 +115,7 @@ public class CdContractExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -100,6 +123,7 @@ public class CdContractExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -107,681 +131,817 @@ public class CdContractExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 判断ID是否为空
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 判断ID是否不为空
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 判断ID是否等于某个值
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 判断ID是否不等于某个值
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 判断ID是否大于某个值
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 判断ID是否大于等于某个值
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 判断ID是否小于某个值
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 判断ID是否小于等于某个值
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否为空
public Criteria andContractCodeIsNull() {
addCriterion("CONTRACT_CODE is null");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否不为空
public Criteria andContractCodeIsNotNull() {
addCriterion("CONTRACT_CODE is not null");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否等于某个值
public Criteria andContractCodeEqualTo(String value) {
addCriterion("CONTRACT_CODE =", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否不等于某个值
public Criteria andContractCodeNotEqualTo(String value) {
addCriterion("CONTRACT_CODE <>", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否大于某个值
public Criteria andContractCodeGreaterThan(String value) {
addCriterion("CONTRACT_CODE >", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否大于等于某个值
public Criteria andContractCodeGreaterThanOrEqualTo(String value) {
addCriterion("CONTRACT_CODE >=", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否小于某个值
public Criteria andContractCodeLessThan(String value) {
addCriterion("CONTRACT_CODE <", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否小于等于某个值
public Criteria andContractCodeLessThanOrEqualTo(String value) {
addCriterion("CONTRACT_CODE <=", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否包含某个值
public Criteria andContractCodeLike(String value) {
addCriterion("CONTRACT_CODE like", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否不包含某个值
public Criteria andContractCodeNotLike(String value) {
addCriterion("CONTRACT_CODE not like", value, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否在某个范围内
public Criteria andContractCodeIn(List<String> values) {
addCriterion("CONTRACT_CODE in", values, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否不在某个范围内
public Criteria andContractCodeNotIn(List<String> values) {
addCriterion("CONTRACT_CODE not in", values, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否在某个范围内
public Criteria andContractCodeBetween(String value1, String value2) {
addCriterion("CONTRACT_CODE between", value1, value2, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_CODE是否不在某个范围内
public Criteria andContractCodeNotBetween(String value1, String value2) {
addCriterion("CONTRACT_CODE not between", value1, value2, "contractCode");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否为空
public Criteria andContractNameIsNull() {
addCriterion("CONTRACT_NAME is null");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否不为空
public Criteria andContractNameIsNotNull() {
addCriterion("CONTRACT_NAME is not null");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否等于某个值
public Criteria andContractNameEqualTo(String value) {
addCriterion("CONTRACT_NAME =", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否不等于某个值
public Criteria andContractNameNotEqualTo(String value) {
addCriterion("CONTRACT_NAME <>", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否大于某个值
public Criteria andContractNameGreaterThan(String value) {
addCriterion("CONTRACT_NAME >", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否大于等于某个值
public Criteria andContractNameGreaterThanOrEqualTo(String value) {
addCriterion("CONTRACT_NAME >=", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否小于某个值
public Criteria andContractNameLessThan(String value) {
addCriterion("CONTRACT_NAME <", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否小于等于某个值
public Criteria andContractNameLessThanOrEqualTo(String value) {
addCriterion("CONTRACT_NAME <=", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否包含某个值
public Criteria andContractNameLike(String value) {
addCriterion("CONTRACT_NAME like", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否不包含某个值
public Criteria andContractNameNotLike(String value) {
addCriterion("CONTRACT_NAME not like", value, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否在某个范围内
public Criteria andContractNameIn(List<String> values) {
addCriterion("CONTRACT_NAME in", values, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否不在某个范围内
public Criteria andContractNameNotIn(List<String> values) {
addCriterion("CONTRACT_NAME not in", values, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否在某个范围内
public Criteria andContractNameBetween(String value1, String value2) {
addCriterion("CONTRACT_NAME between", value1, value2, "contractName");
return (Criteria) this;
}
// 判断CONTRACT_NAME是否不在某个范围内
public Criteria andContractNameNotBetween(String value1, String value2) {
addCriterion("CONTRACT_NAME not between", value1, value2, "contractName");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否为空
public Criteria andCdMemberIdIsNull() {
addCriterion("CD_MEMBER_ID is null");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否不为空
public Criteria andCdMemberIdIsNotNull() {
addCriterion("CD_MEMBER_ID is not null");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否等于某个值
public Criteria andCdMemberIdEqualTo(Integer value) {
addCriterion("CD_MEMBER_ID =", value, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否不等于某个值
public Criteria andCdMemberIdNotEqualTo(Integer value) {
addCriterion("CD_MEMBER_ID <>", value, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否大于某个值
public Criteria andCdMemberIdGreaterThan(Integer value) {
addCriterion("CD_MEMBER_ID >", value, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否大于等于某个值
public Criteria andCdMemberIdGreaterThanOrEqualTo(Integer value) {
addCriterion("CD_MEMBER_ID >=", value, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否小于某个值
public Criteria andCdMemberIdLessThan(Integer value) {
addCriterion("CD_MEMBER_ID <", value, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否小于等于某个值
public Criteria andCdMemberIdLessThanOrEqualTo(Integer value) {
addCriterion("CD_MEMBER_ID <=", value, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否在某个范围内
public Criteria andCdMemberIdIn(List<Integer> values) {
addCriterion("CD_MEMBER_ID in", values, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否不在某个范围内
public Criteria andCdMemberIdNotIn(List<Integer> values) {
addCriterion("CD_MEMBER_ID not in", values, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否在某个范围内
public Criteria andCdMemberIdBetween(Integer value1, Integer value2) {
addCriterion("CD_MEMBER_ID between", value1, value2, "cdMemberId");
return (Criteria) this;
}
// 判断CD_MEMBER_ID是否不在某个范围内
public Criteria andCdMemberIdNotBetween(Integer value1, Integer value2) {
addCriterion("CD_MEMBER_ID not between", value1, value2, "cdMemberId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否为空
public Criteria andCdCompanyIdIsNull() {
addCriterion("CD_COMPANY_ID is null");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否不为空
public Criteria andCdCompanyIdIsNotNull() {
addCriterion("CD_COMPANY_ID is not null");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否等于某个值
public Criteria andCdCompanyIdEqualTo(Integer value) {
addCriterion("CD_COMPANY_ID =", value, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否不等于某个值
public Criteria andCdCompanyIdNotEqualTo(Integer value) {
addCriterion("CD_COMPANY_ID <>", value, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否大于某个值
public Criteria andCdCompanyIdGreaterThan(Integer value) {
addCriterion("CD_COMPANY_ID >", value, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否大于等于某个值
public Criteria andCdCompanyIdGreaterThanOrEqualTo(Integer value) {
addCriterion("CD_COMPANY_ID >=", value, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否小于某个值
public Criteria andCdCompanyIdLessThan(Integer value) {
addCriterion("CD_COMPANY_ID <", value, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否小于等于某个值
public Criteria andCdCompanyIdLessThanOrEqualTo(Integer value) {
addCriterion("CD_COMPANY_ID <=", value, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否在某个范围内
public Criteria andCdCompanyIdIn(List<Integer> values) {
addCriterion("CD_COMPANY_ID in", values, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否不在某个范围内
public Criteria andCdCompanyIdNotIn(List<Integer> values) {
addCriterion("CD_COMPANY_ID not in", values, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否在某个范围内
public Criteria andCdCompanyIdBetween(Integer value1, Integer value2) {
addCriterion("CD_COMPANY_ID between", value1, value2, "cdCompanyId");
return (Criteria) this;
}
// 判断CD_COMPANY_ID是否不在某个范围内
public Criteria andCdCompanyIdNotBetween(Integer value1, Integer value2) {
addCriterion("CD_COMPANY_ID not between", value1, value2, "cdCompanyId");
return (Criteria) this;
}
// 判断SCOPE是否为空
public Criteria andScopeIsNull() {
addCriterion("SCOPE is null");
return (Criteria) this;
}
// 判断SCOPE是否不为空
public Criteria andScopeIsNotNull() {
addCriterion("SCOPE is not null");
return (Criteria) this;
}
// 判断SCOPE是否等于某个值
public Criteria andScopeEqualTo(Integer value) {
addCriterion("SCOPE =", value, "scope");
return (Criteria) this;
}
// 判断SCOPE是否不等于某个值
public Criteria andScopeNotEqualTo(Integer value) {
addCriterion("SCOPE <>", value, "scope");
return (Criteria) this;
}
// 判断SCOPE是否大于某个值
public Criteria andScopeGreaterThan(Integer value) {
addCriterion("SCOPE >", value, "scope");
return (Criteria) this;
}
// 判断SCOPE是否大于等于某个值
public Criteria andScopeGreaterThanOrEqualTo(Integer value) {
addCriterion("SCOPE >=", value, "scope");
return (Criteria) this;
}
// 判断SCOPE是否小于某个值
public Criteria andScopeLessThan(Integer value) {
addCriterion("SCOPE <", value, "scope");
return (Criteria) this;
}
// 判断SCOPE是否小于等于某个值
public Criteria andScopeLessThanOrEqualTo(Integer value) {
addCriterion("SCOPE <=", value, "scope");
return (Criteria) this;
}
// 判断SCOPE是否在某个范围内
public Criteria andScopeIn(List<Integer> values) {
addCriterion("SCOPE in", values, "scope");
return (Criteria) this;
}
// 判断SCOPE是否不在某个范围内
public Criteria andScopeNotIn(List<Integer> values) {
addCriterion("SCOPE not in", values, "scope");
return (Criteria) this;
}
// 判断SCOPE是否在某个范围内
public Criteria andScopeBetween(Integer value1, Integer value2) {
addCriterion("SCOPE between", value1, value2, "scope");
return (Criteria) this;
}
// 判断SCOPE是否不在某个范围内
public Criteria andScopeNotBetween(Integer value1, Integer value2) {
addCriterion("SCOPE not between", value1, value2, "scope");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否为空
public Criteria andContractPriceIsNull() {
addCriterion("CONTRACT_PRICE is null");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否不为空
public Criteria andContractPriceIsNotNull() {
addCriterion("CONTRACT_PRICE is not null");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否等于某个值
public Criteria andContractPriceEqualTo(BigDecimal value) {
addCriterion("CONTRACT_PRICE =", value, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否不等于某个值
public Criteria andContractPriceNotEqualTo(BigDecimal value) {
addCriterion("CONTRACT_PRICE <>", value, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否大于某个值
public Criteria andContractPriceGreaterThan(BigDecimal value) {
addCriterion("CONTRACT_PRICE >", value, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否大于等于某个值
public Criteria andContractPriceGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("CONTRACT_PRICE >=", value, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否小于某个值
public Criteria andContractPriceLessThan(BigDecimal value) {
addCriterion("CONTRACT_PRICE <", value, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否小于等于某个值
public Criteria andContractPriceLessThanOrEqualTo(BigDecimal value) {
addCriterion("CONTRACT_PRICE <=", value, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否在某个范围内
public Criteria andContractPriceIn(List<BigDecimal> values) {
addCriterion("CONTRACT_PRICE in", values, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否不在某个范围内
public Criteria andContractPriceNotIn(List<BigDecimal> values) {
addCriterion("CONTRACT_PRICE not in", values, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否在某个范围内
public Criteria andContractPriceBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("CONTRACT_PRICE between", value1, value2, "contractPrice");
return (Criteria) this;
}
// 判断CONTRACT_PRICE是否不在某个范围内
public Criteria andContractPriceNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("CONTRACT_PRICE not between", value1, value2, "contractPrice");
return (Criteria) this;
}
// 判断BEGIN_TIME是否为空
public Criteria andBeginTimeIsNull() {
addCriterion("BEGIN_TIME is null");
return (Criteria) this;
}
// 判断BEGIN_TIME是否不为空
public Criteria andBeginTimeIsNotNull() {
addCriterion("BEGIN_TIME is not null");
return (Criteria) this;
}
// 判断BEGIN_TIME是否等于某个值
public Criteria andBeginTimeEqualTo(Date value) {
addCriterion("BEGIN_TIME =", value, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否不等于某个值
public Criteria andBeginTimeNotEqualTo(Date value) {
addCriterion("BEGIN_TIME <>", value, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否大于某个值
public Criteria andBeginTimeGreaterThan(Date value) {
addCriterion("BEGIN_TIME >", value, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否大于等于某个值
public Criteria andBeginTimeGreaterThanOrEqualTo(Date value) {
addCriterion("BEGIN_TIME >=", value, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否小于某个值
public Criteria andBeginTimeLessThan(Date value) {
addCriterion("BEGIN_TIME <", value, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否小于等于某个值
public Criteria andBeginTimeLessThanOrEqualTo(Date value) {
addCriterion("BEGIN_TIME <=", value, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否在某个范围内
public Criteria andBeginTimeIn(List<Date> values) {
addCriterion("BEGIN_TIME in", values, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否不在某个范围内
public Criteria andBeginTimeNotIn(List<Date> values) {
addCriterion("BEGIN_TIME not in", values, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否在某个范围内
public Criteria andBeginTimeBetween(Date value1, Date value2) {
addCriterion("BEGIN_TIME between", value1, value2, "beginTime");
return (Criteria) this;
}
// 判断BEGIN_TIME是否不在某个范围内
public Criteria andBeginTimeNotBetween(Date value1, Date value2) {
addCriterion("BEGIN_TIME not between", value1, value2, "beginTime");
return (Criteria) this;
}
// 判断END_TIME是否为空
public Criteria andEndTimeIsNull() {
addCriterion("END_TIME is null");
return (Criteria) this;
}
// 判断END_TIME是否不为空
public Criteria andEndTimeIsNotNull() {
addCriterion("END_TIME is not null");
return (Criteria) this;
}
// 判断END_TIME是否等于某个值
public Criteria andEndTimeEqualTo(Date value) {
addCriterion("END_TIME =", value, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否不等于某个值
public Criteria andEndTimeNotEqualTo(Date value) {
addCriterion("END_TIME <>", value, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否大于某个值
public Criteria andEndTimeGreaterThan(Date value) {
addCriterion("END_TIME >", value, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否大于等于某个值
public Criteria andEndTimeGreaterThanOrEqualTo(Date value) {
addCriterion("END_TIME >=", value, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否小于某个值
public Criteria andEndTimeLessThan(Date value) {
addCriterion("END_TIME <", value, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否小于等于某个值
public Criteria andEndTimeLessThanOrEqualTo(Date value) {
addCriterion("END_TIME <=", value, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否在某个范围内
public Criteria andEndTimeIn(List<Date> values) {
addCriterion("END_TIME in", values, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否不在某个范围内
public Criteria andEndTimeNotIn(List<Date> values) {
addCriterion("END_TIME not in", values, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否在某个范围内
public Criteria andEndTimeBetween(Date value1, Date value2) {
addCriterion("END_TIME between", value1, value2, "endTime");
return (Criteria) this;
}
// 判断END_TIME是否不在某个范围内
public Criteria andEndTimeNotBetween(Date value1, Date value2) {
addCriterion("END_TIME not between", value1, value2, "endTime");
return (Criteria) this;
}
// 判断IS_DEL是否为空
public Criteria andIsDelIsNull() {
addCriterion("IS_DEL is null");
return (Criteria) this;
}
// 判断IS_DEL是否不为空
public Criteria andIsDelIsNotNull() {
addCriterion("IS_DEL is not null");
return (Criteria) this;
}
// 判断IS_DEL是否等于某个值
public Criteria andIsDelEqualTo(Integer value) {
addCriterion("IS_DEL =", value, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否不等于某个值
public Criteria andIsDelNotEqualTo(Integer value) {
addCriterion("IS_DEL <>", value, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否大于某个值
public Criteria andIsDelGreaterThan(Integer value) {
addCriterion("IS_DEL >", value, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否大于等于某个值
public Criteria andIsDelGreaterThanOrEqualTo(Integer value) {
addCriterion("IS_DEL >=", value, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否小于某个值
public Criteria andIsDelLessThan(Integer value) {
addCriterion("IS_DEL <", value, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否小于等于某个值
public Criteria andIsDelLessThanOrEqualTo(Integer value) {
addCriterion("IS_DEL <=", value, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否在某个范围内
public Criteria andIsDelIn(List<Integer> values) {
addCriterion("IS_DEL in", values, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否不在某个范围内
public Criteria andIsDelNotIn(List<Integer> values) {
addCriterion("IS_DEL not in", values, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否在某个范围内
public Criteria andIsDelBetween(Integer value1, Integer value2) {
addCriterion("IS_DEL between", value1, value2, "isDel");
return (Criteria) this;
}
// 判断IS_DEL是否不在某个范围内
public Criteria andIsDelNotBetween(Integer value1, Integer value2) {
addCriterion("IS_DEL not between", value1, value2, "isDel");
return (Criteria) this;
}
// 判断IS_AUDITOR是否为空
public Criteria andIsAuditorIsNull() {
addCriterion("IS_AUDITOR is null");
return (Criteria) this;
}
// 判断IS_AUDITOR是否不为空
public Criteria andIsAuditorIsNotNull() {
addCriterion("IS_AUDITOR is not null");
return (Criteria) this;
}
// 判断IS_AUDITOR是否等于某个值
public Criteria andIsAuditorEqualTo(Integer value) {
addCriterion("IS_AUDITOR =", value, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否不等于某个值
public Criteria andIsAuditorNotEqualTo(Integer value) {
addCriterion("IS_AUDITOR <>", value, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否大于某个值
public Criteria andIsAuditorGreaterThan(Integer value) {
addCriterion("IS_AUDITOR >", value, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否大于等于某个值
public Criteria andIsAuditorGreaterThanOrEqualTo(Integer value) {
addCriterion("IS_AUDITOR >=", value, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否小于某个值
public Criteria andIsAuditorLessThan(Integer value) {
addCriterion("IS_AUDITOR <", value, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否小于等于某个值
public Criteria andIsAuditorLessThanOrEqualTo(Integer value) {
addCriterion("IS_AUDITOR <=", value, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否在某个范围内
public Criteria andIsAuditorIn(List<Integer> values) {
addCriterion("IS_AUDITOR in", values, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否不在某个范围内
public Criteria andIsAuditorNotIn(List<Integer> values) {
addCriterion("IS_AUDITOR not in", values, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否在某个范围内
public Criteria andIsAuditorBetween(Integer value1, Integer value2) {
addCriterion("IS_AUDITOR between", value1, value2, "isAuditor");
return (Criteria) this;
}
// 判断IS_AUDITOR是否不在某个范围内
public Criteria andIsAuditorNotBetween(Integer value1, Integer value2) {
addCriterion("IS_AUDITOR not between", value1, value2, "isAuditor");
return (Criteria) this;

25
src/main/java/com/xmomen/module/base/entity/CdContractItem.java
Unescape View File

@ -12,34 +12,23 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_contract_item")
public class CdContractItem extends BaseMybatisModel {
/**
*
*/
// 合同项ID
private Integer id;
/**
* 产品合同
*/
// 合同ID
private Integer cdContractId;
/**
* 优惠方式
*/
// 合同类型
private Integer contractType;
/**
* 当合同适用范围为1的时候，每种产品要设定对应的合同价
*/
// 合同项ID
private Integer cdItemId;
/**
* 折扣
*/
// 折扣
private BigDecimal discount;
/**
* 合同价格
*/
// 合同金额
private BigDecimal contractValue;
@Column(name = "ID")

96
src/main/java/com/xmomen/module/base/entity/CdContractItemExample.java
Unescape View File

@ -5,47 +5,60 @@ import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
// 定义一个名为CdContractItemExample的类，继承自BaseMybatisExample
public class CdContractItemExample extends BaseMybatisExample {
// 定义一个orderByClause变量，用于存储排序的子句
protected String orderByClause;
// 定义一个distinct变量，用于存储是否去重的标志
protected boolean distinct;
// 定义一个oredCriteria变量，用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数，初始化oredCriteria
public CdContractItemExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置orderByClause的值
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取orderByClause的值
public String getOrderByClause() {
return orderByClause;
}
// 设置distinct的值
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取distinct的值
public boolean isDistinct() {
return distinct;
}
// 获取oredCriteria的值
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加一个查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个新的查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -54,37 +67,46 @@ public class CdContractItemExample extends BaseMybatisExample {
return criteria;
}
// 创建一个新的查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空oredCriteria、orderByClause和distinct的值
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 定义一个内部类GeneratedCriteria，用于存储查询条件
protected abstract static class GeneratedCriteria {
// 定义一个criteria变量，用于存储查询条件
protected List<Criterion> criteria;
// 构造函数，初始化criteria
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
// 判断是否有查询条件
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有的查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加一个查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -92,6 +114,7 @@ public class CdContractItemExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -99,6 +122,7 @@ public class CdContractItemExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加一个查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -106,361 +130,433 @@ public class CdContractItemExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 判断ID是否为空
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 判断ID是否不为空
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 判断ID是否等于某个值
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 判断ID是否不等于某个值
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 判断ID是否大于某个值
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 判断ID是否大于等于某个值
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 判断ID是否小于某个值
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 判断ID是否小于等于某个值
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 判断ID是否在某个范围内
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 判断ID是否不在某个范围内
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否为空
public Criteria andCdContractIdIsNull() {
addCriterion("CD_CONTRACT_ID is null");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否不为空
public Criteria andCdContractIdIsNotNull() {
addCriterion("CD_CONTRACT_ID is not null");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否等于某个值
public Criteria andCdContractIdEqualTo(Integer value) {
addCriterion("CD_CONTRACT_ID =", value, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否不等于某个值
public Criteria andCdContractIdNotEqualTo(Integer value) {
addCriterion("CD_CONTRACT_ID <>", value, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否大于某个值
public Criteria andCdContractIdGreaterThan(Integer value) {
addCriterion("CD_CONTRACT_ID >", value, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否大于等于某个值
public Criteria andCdContractIdGreaterThanOrEqualTo(Integer value) {
addCriterion("CD_CONTRACT_ID >=", value, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否小于某个值
public Criteria andCdContractIdLessThan(Integer value) {
addCriterion("CD_CONTRACT_ID <", value, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否小于等于某个值
public Criteria andCdContractIdLessThanOrEqualTo(Integer value) {
addCriterion("CD_CONTRACT_ID <=", value, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否在某个范围内
public Criteria andCdContractIdIn(List<Integer> values) {
addCriterion("CD_CONTRACT_ID in", values, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否不在某个范围内
public Criteria andCdContractIdNotIn(List<Integer> values) {
addCriterion("CD_CONTRACT_ID not in", values, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否在某个范围内
public Criteria andCdContractIdBetween(Integer value1, Integer value2) {
addCriterion("CD_CONTRACT_ID between", value1, value2, "cdContractId");
return (Criteria) this;
}
// 判断CD_CONTRACT_ID是否不在某个范围内
public Criteria andCdContractIdNotBetween(Integer value1, Integer value2) {
addCriterion("CD_CONTRACT_ID not between", value1, value2, "cdContractId");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否为空
public Criteria andContractTypeIsNull() {
addCriterion("CONTRACT_TYPE is null");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否不为空
public Criteria andContractTypeIsNotNull() {
addCriterion("CONTRACT_TYPE is not null");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否等于某个值
public Criteria andContractTypeEqualTo(Integer value) {
addCriterion("CONTRACT_TYPE =", value, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否不等于某个值
public Criteria andContractTypeNotEqualTo(Integer value) {
addCriterion("CONTRACT_TYPE <>", value, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否大于某个值
public Criteria andContractTypeGreaterThan(Integer value) {
addCriterion("CONTRACT_TYPE >", value, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否大于等于某个值
public Criteria andContractTypeGreaterThanOrEqualTo(Integer value) {
addCriterion("CONTRACT_TYPE >=", value, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否小于某个值
public Criteria andContractTypeLessThan(Integer value) {
addCriterion("CONTRACT_TYPE <", value, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否小于等于某个值
public Criteria andContractTypeLessThanOrEqualTo(Integer value) {
addCriterion("CONTRACT_TYPE <=", value, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否在某个范围内
public Criteria andContractTypeIn(List<Integer> values) {
addCriterion("CONTRACT_TYPE in", values, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否不在某个范围内
public Criteria andContractTypeNotIn(List<Integer> values) {
addCriterion("CONTRACT_TYPE not in", values, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否在某个范围内
public Criteria andContractTypeBetween(Integer value1, Integer value2) {
addCriterion("CONTRACT_TYPE between", value1, value2, "contractType");
return (Criteria) this;
}
// 判断CONTRACT_TYPE是否不在某个范围内
public Criteria andContractTypeNotBetween(Integer value1, Integer value2) {
addCriterion("CONTRACT_TYPE not between", value1, value2, "contractType");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否为空
public Criteria andCdItemIdIsNull() {
addCriterion("CD_ITEM_ID is null");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否不为空
public Criteria andCdItemIdIsNotNull() {
addCriterion("CD_ITEM_ID is not null");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否等于某个值
public Criteria andCdItemIdEqualTo(Integer value) {
addCriterion("CD_ITEM_ID =", value, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否不等于某个值
public Criteria andCdItemIdNotEqualTo(Integer value) {
addCriterion("CD_ITEM_ID <>", value, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否大于某个值
public Criteria andCdItemIdGreaterThan(Integer value) {
addCriterion("CD_ITEM_ID >", value, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否大于等于某个值
public Criteria andCdItemIdGreaterThanOrEqualTo(Integer value) {
addCriterion("CD_ITEM_ID >=", value, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否小于某个值
public Criteria andCdItemIdLessThan(Integer value) {
addCriterion("CD_ITEM_ID <", value, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否小于等于某个值
public Criteria andCdItemIdLessThanOrEqualTo(Integer value) {
addCriterion("CD_ITEM_ID <=", value, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否在某个范围内
public Criteria andCdItemIdIn(List<Integer> values) {
addCriterion("CD_ITEM_ID in", values, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否不在某个范围内
public Criteria andCdItemIdNotIn(List<Integer> values) {
addCriterion("CD_ITEM_ID not in", values, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否在某个范围内
public Criteria andCdItemIdBetween(Integer value1, Integer value2) {
addCriterion("CD_ITEM_ID between", value1, value2, "cdItemId");
return (Criteria) this;
}
// 判断CD_ITEM_ID是否不在某个范围内
public Criteria andCdItemIdNotBetween(Integer value1, Integer value2) {
addCriterion("CD_ITEM_ID not between", value1, value2, "cdItemId");
return (Criteria) this;
}
// 判断DISCOUNT是否为空
public Criteria andDiscountIsNull() {
addCriterion("DISCOUNT is null");
return (Criteria) this;
}
// 判断DISCOUNT是否不为空
public Criteria andDiscountIsNotNull() {
addCriterion("DISCOUNT is not null");
return (Criteria) this;
}
// 判断DISCOUNT是否等于某个值
public Criteria andDiscountEqualTo(BigDecimal value) {
addCriterion("DISCOUNT =", value, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否不等于某个值
public Criteria andDiscountNotEqualTo(BigDecimal value) {
addCriterion("DISCOUNT <>", value, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否大于某个值
public Criteria andDiscountGreaterThan(BigDecimal value) {
addCriterion("DISCOUNT >", value, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否大于等于某个值
public Criteria andDiscountGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("DISCOUNT >=", value, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否小于某个值
public Criteria andDiscountLessThan(BigDecimal value) {
addCriterion("DISCOUNT <", value, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否小于等于某个值
public Criteria andDiscountLessThanOrEqualTo(BigDecimal value) {
addCriterion("DISCOUNT <=", value, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否在某个范围内
public Criteria andDiscountIn(List<BigDecimal> values) {
addCriterion("DISCOUNT in", values, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否不在某个范围内
public Criteria andDiscountNotIn(List<BigDecimal> values) {
addCriterion("DISCOUNT not in", values, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否在某个范围内
public Criteria andDiscountBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("DISCOUNT between", value1, value2, "discount");
return (Criteria) this;
}
// 判断DISCOUNT是否不在某个范围内
public Criteria andDiscountNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("DISCOUNT not between", value1, value2, "discount");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否为空
public Criteria andContractValueIsNull() {
addCriterion("CONTRACT_VALUE is null");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否不为空
public Criteria andContractValueIsNotNull() {
addCriterion("CONTRACT_VALUE is not null");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否等于某个值
public Criteria andContractValueEqualTo(BigDecimal value) {
addCriterion("CONTRACT_VALUE =", value, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否不等于某个值
public Criteria andContractValueNotEqualTo(BigDecimal value) {
addCriterion("CONTRACT_VALUE <>", value, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否大于某个值
public Criteria andContractValueGreaterThan(BigDecimal value) {
addCriterion("CONTRACT_VALUE >", value, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否大于等于某个值
public Criteria andContractValueGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("CONTRACT_VALUE >=", value, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否小于某个值
public Criteria andContractValueLessThan(BigDecimal value) {
addCriterion("CONTRACT_VALUE <", value, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否小于等于某个值
public Criteria andContractValueLessThanOrEqualTo(BigDecimal value) {
addCriterion("CONTRACT_VALUE <=", value, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否在某个范围内
public Criteria andContractValueIn(List<BigDecimal> values) {
addCriterion("CONTRACT_VALUE in", values, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否不在某个范围内
public Criteria andContractValueNotIn(List<BigDecimal> values) {
addCriterion("CONTRACT_VALUE not in", values, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否在某个范围内
public Criteria andContractValueBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("CONTRACT_VALUE between", value1, value2, "contractValue");
return (Criteria) this;
}
// 判断CONTRACT_VALUE是否不在某个范围内
public Criteria andContractValueNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("CONTRACT_VALUE not between", value1, value2, "contractValue");
return (Criteria) this;

89
src/main/java/com/xmomen/module/base/entity/CdCoupon.java
Unescape View File

@ -13,114 +13,71 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_coupon")
public class CdCoupon extends BaseMybatisModel {
/**
*
*/
// 主键ID
private Integer id;
/**
* 卡或者劵,1-卡，2-劵
*/
// 优惠券类型
private Integer couponType;
/**
* 卡/劵类型
*/
// 优惠券类别
private Integer couponCategory;
/**
* 卡号
*/
// 优惠券号码
private String couponNumber;
/**
* 密码
*/
// 优惠券密码
private String couponPassword;
/**
* 固定金额
*/
// 优惠券面值
private BigDecimal couponValue;
/**
* 可用余额
*/
// 用户价格
private BigDecimal userPrice;
/**
* 单位
*/
// 公司ID
private Integer cdCompanyId;
/**
* 客服经理
*/
// 用户ID
private Integer cdUserId;
/**
* 描述
*/
// 优惠券描述
private String couponDesc;
/**
* 0-未使用，1-已使用
*/
// 是否使用
private Integer isUsed;
/**
* 0-无效，1-有效
*/
// 是否有效
private Integer isUseful;
/**
* 是否赠送。0-否，1-是
*/
// 是否赠送
private Integer isGift;
/**
* 是否发卡，0-未发，1-已发
*/
// 是否发送
private Integer isSend;
/**
* 付款方式 1-预付款，2-后付款
*/
// 支付类型
private Integer paymentType;
/**
* 有效开始时间
*/
// 开始时间
private Date beginTime;
/**
* 有效结束时间
*/
// 结束时间
private Date endTime;
/**
*
*/
// 备注
private String notes;
/**
* 0-未完结 1-完结
*/
// 是否过期
private Integer isOver;
/**
* 审核时间
*/
// 审核日期
private Date auditDate;
/**
* 发卡批次
*/
// 批次
private String batch;
/**
* 卡激活时间，劵使用时间
*/
// 有效日期
private Date usefulDate;
@Column(name = "ID")

13
src/main/java/com/xmomen/module/base/entity/CdCouponCategory.java
Unescape View File

@ -11,19 +11,14 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_coupon_category")
public class CdCouponCategory extends BaseMybatisModel {
/**
*
*/
// 主键ID
private Integer id;
/**
* 类别类型(1-卡，2-劵)
*/
// 优惠券类型
private Integer categoryType;
/**
* 类别名称
*/
// 优惠券名称
private String categoryName;
@Column(name = "ID")

75
src/main/java/com/xmomen/module/base/entity/CdCouponCategoryExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 优惠券分类实体类
public class CdCouponCategoryExample extends BaseMybatisExample {
// 排序字段
protected String orderByClause;
// 是否去重
protected boolean distinct;
// 查询条件
protected List<Criteria> oredCriteria;
// 构造函数
public CdCouponCategoryExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置排序字段
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取排序字段
public String getOrderByClause() {
return orderByClause;
}
// 设置是否去重
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取是否去重
public boolean isDistinct() {
return distinct;
}
// 获取查询条件
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -53,17 +66,20 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
return criteria;
}
// 创建查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空查询条件
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 生成查询条件
protected abstract static class GeneratedCriteria {
protected List<Criterion> criteria;
@ -72,18 +88,22 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
criteria = new ArrayList<Criterion>();
}
// 判断查询条件是否有效
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -91,6 +111,7 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -98,6 +119,7 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -105,197 +127,236 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 添加ID为空的查询条件
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 添加ID不为空的查询条件
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 添加ID等于指定值的查询条件
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 添加ID不等于指定值的查询条件
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 添加ID大于指定值的查询条件
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 添加ID大于等于指定值的查询条件
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 添加ID小于指定值的查询条件
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 添加ID小于等于指定值的查询条件
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 添加ID在指定值范围内的查询条件
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 添加ID不在指定值范围内的查询条件
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 添加ID在指定值范围内的查询条件
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 添加ID不在指定值范围内的查询条件
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 添加分类类型为空的查询条件
public Criteria andCategoryTypeIsNull() {
addCriterion("CATEGORY_TYPE is null");
return (Criteria) this;
}
// 添加分类类型不为空的查询条件
public Criteria andCategoryTypeIsNotNull() {
addCriterion("CATEGORY_TYPE is not null");
return (Criteria) this;
}
// 添加分类类型等于指定值的查询条件
public Criteria andCategoryTypeEqualTo(Integer value) {
addCriterion("CATEGORY_TYPE =", value, "categoryType");
return (Criteria) this;
}
// 添加分类类型不等于指定值的查询条件
public Criteria andCategoryTypeNotEqualTo(Integer value) {
addCriterion("CATEGORY_TYPE <>", value, "categoryType");
return (Criteria) this;
}
// 添加分类类型大于指定值的查询条件
public Criteria andCategoryTypeGreaterThan(Integer value) {
addCriterion("CATEGORY_TYPE >", value, "categoryType");
return (Criteria) this;
}
// 添加分类类型大于等于指定值的查询条件
public Criteria andCategoryTypeGreaterThanOrEqualTo(Integer value) {
addCriterion("CATEGORY_TYPE >=", value, "categoryType");
return (Criteria) this;
}
// 添加分类类型小于指定值的查询条件
public Criteria andCategoryTypeLessThan(Integer value) {
addCriterion("CATEGORY_TYPE <", value, "categoryType");
return (Criteria) this;
}
// 添加分类类型小于等于指定值的查询条件
public Criteria andCategoryTypeLessThanOrEqualTo(Integer value) {
addCriterion("CATEGORY_TYPE <=", value, "categoryType");
return (Criteria) this;
}
// 添加分类类型在指定值范围内的查询条件
public Criteria andCategoryTypeIn(List<Integer> values) {
addCriterion("CATEGORY_TYPE in", values, "categoryType");
return (Criteria) this;
}
// 添加分类类型不在指定值范围内的查询条件
public Criteria andCategoryTypeNotIn(List<Integer> values) {
addCriterion("CATEGORY_TYPE not in", values, "categoryType");
return (Criteria) this;
}
// 添加分类类型在指定值范围内的查询条件
public Criteria andCategoryTypeBetween(Integer value1, Integer value2) {
addCriterion("CATEGORY_TYPE between", value1, value2, "categoryType");
return (Criteria) this;
}
// 添加分类类型不在指定值范围内的查询条件
public Criteria andCategoryTypeNotBetween(Integer value1, Integer value2) {
addCriterion("CATEGORY_TYPE not between", value1, value2, "categoryType");
return (Criteria) this;
}
// 添加分类名称为空的查询条件
public Criteria andCategoryNameIsNull() {
addCriterion("CATEGORY_NAME is null");
return (Criteria) this;
}
// 添加分类名称不为空的查询条件
public Criteria andCategoryNameIsNotNull() {
addCriterion("CATEGORY_NAME is not null");
return (Criteria) this;
}
// 添加分类名称等于指定值的查询条件
public Criteria andCategoryNameEqualTo(String value) {
addCriterion("CATEGORY_NAME =", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称不等于指定值的查询条件
public Criteria andCategoryNameNotEqualTo(String value) {
addCriterion("CATEGORY_NAME <>", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称大于指定值的查询条件
public Criteria andCategoryNameGreaterThan(String value) {
addCriterion("CATEGORY_NAME >", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称大于等于指定值的查询条件
public Criteria andCategoryNameGreaterThanOrEqualTo(String value) {
addCriterion("CATEGORY_NAME >=", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称小于指定值的查询条件
public Criteria andCategoryNameLessThan(String value) {
addCriterion("CATEGORY_NAME <", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称小于等于指定值的查询条件
public Criteria andCategoryNameLessThanOrEqualTo(String value) {
addCriterion("CATEGORY_NAME <=", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称包含指定值的查询条件
public Criteria andCategoryNameLike(String value) {
addCriterion("CATEGORY_NAME like", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称不包含指定值的查询条件
public Criteria andCategoryNameNotLike(String value) {
addCriterion("CATEGORY_NAME not like", value, "categoryName");
return (Criteria) this;
}
// 添加分类名称在指定值范围内的查询条件
public Criteria andCategoryNameIn(List<String> values) {
addCriterion("CATEGORY_NAME in", values, "categoryName");
return (Criteria) this;
}
// 添加分类名称不在指定值范围内的查询条件
public Criteria andCategoryNameNotIn(List<String> values) {
addCriterion("CATEGORY_NAME not in", values, "categoryName");
return (Criteria) this;
}
// 添加分类名称在指定值范围内的查询条件
public Criteria andCategoryNameBetween(String value1, String value2) {
addCriterion("CATEGORY_NAME between", value1, value2, "categoryName");
return (Criteria) this;
}
// 添加分类名称不在指定值范围内的查询条件
public Criteria andCategoryNameNotBetween(String value1, String value2) {
addCriterion("CATEGORY_NAME not between", value1, value2, "categoryName");
return (Criteria) this;
}
}
// 生成查询条件
public static class Criteria extends GeneratedCriteria {
protected Criteria() {
@ -303,6 +364,7 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
}
}
// 生成查询条件
public static class Criterion {
private String condition;
@ -320,38 +382,47 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
private String typeHandler;
// 获取查询条件
public String getCondition() {
return condition;
}
// 获取查询条件的值
public Object getValue() {
return value;
}
// 获取查询条件的第二个值
public Object getSecondValue() {
return secondValue;
}
// 判断查询条件是否为空
public boolean isNoValue() {
return noValue;
}
// 判断查询条件是否为单个值
public boolean isSingleValue() {
return singleValue;
}
// 判断查询条件是否为范围值
public boolean isBetweenValue() {
return betweenValue;
}
// 判断查询条件是否为列表值
public boolean isListValue() {
return listValue;
}
// 获取查询条件的类型处理器
public String getTypeHandler() {
return typeHandler;
}
// 创建查询条件
protected Criterion(String condition) {
super();
this.condition = condition;
@ -359,6 +430,7 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
this.noValue = true;
}
// 创建查询条件
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
@ -371,10 +443,12 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
}
}
// 创建查询条件
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
// 创建查询条件
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
@ -384,6 +458,7 @@ public class CdCouponCategoryExample extends BaseMybatisExample {
this.betweenValue = true;
}
// 创建查询条件
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

25
src/main/java/com/xmomen/module/base/entity/CdCouponCategoryRef.java
Unescape View File

@ -11,34 +11,23 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_coupon_category_ref")
public class CdCouponCategoryRef extends BaseMybatisModel {
/**
*
*/
// 主键ID
private Integer id;
/**
* 卡劵类别
*/
// 优惠券分类ID
private Integer cdCouponCategoryId;
/**
* 拓展类型
*/
// 引用类型
private String refType;
/**
* 拓展描述
*/
// 引用名称
private String refName;
/**
* 拓展值
*/
// 引用值
private String refValue;
/**
* 份数
*/
// 引用数量
private Integer refCount;
@Column(name = "ID")

102
src/main/java/com/xmomen/module/base/entity/CdCouponCategoryRefExample.java
Unescape View File

@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
// 优惠券分类关联实体类
public class CdCouponCategoryRefExample extends BaseMybatisExample {
// 排序字段
protected String orderByClause;
// 是否去重
protected boolean distinct;
// 查询条件
protected List<Criteria> oredCriteria;
// 构造函数
public CdCouponCategoryRefExample() {
oredCriteria = new ArrayList<Criteria>();
}
// 设置排序字段
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取排序字段
public String getOrderByClause() {
return orderByClause;
}
// 设置是否去重
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取是否去重
public boolean isDistinct() {
return distinct;
}
// 获取查询条件
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加查询条件
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建查询条件
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建查询条件
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -53,37 +66,46 @@ public class CdCouponCategoryRefExample extends BaseMybatisExample {
return criteria;
}
// 创建查询条件
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清空查询条件
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
// 生成查询条件
protected abstract static class GeneratedCriteria {
// 查询条件列表
protected List<Criterion> criteria;
// 构造函数
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
// 判断查询条件是否有效
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件
public List<Criterion> getCriteria() {
return criteria;
}
// 添加查询条件
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -91,6 +113,7 @@ public class CdCouponCategoryRefExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
// 添加查询条件
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -98,6 +121,7 @@ public class CdCouponCategoryRefExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
// 添加查询条件
protected void addCriterion(String condition, Object value1, Object value2, String property) {
if (value1 == null || value2 == null) {
throw new RuntimeException("Between values for " + property + " cannot be null");
@ -105,391 +129,469 @@ public class CdCouponCategoryRefExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 添加ID查询条件
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
// 添加ID查询条件
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdIsNull() {
addCriterion("CD_COUPON_CATEGORY_ID is null");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdIsNotNull() {
addCriterion("CD_COUPON_CATEGORY_ID is not null");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdEqualTo(Integer value) {
addCriterion("CD_COUPON_CATEGORY_ID =", value, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdNotEqualTo(Integer value) {
addCriterion("CD_COUPON_CATEGORY_ID <>", value, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdGreaterThan(Integer value) {
addCriterion("CD_COUPON_CATEGORY_ID >", value, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdGreaterThanOrEqualTo(Integer value) {
addCriterion("CD_COUPON_CATEGORY_ID >=", value, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdLessThan(Integer value) {
addCriterion("CD_COUPON_CATEGORY_ID <", value, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdLessThanOrEqualTo(Integer value) {
addCriterion("CD_COUPON_CATEGORY_ID <=", value, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdIn(List<Integer> values) {
addCriterion("CD_COUPON_CATEGORY_ID in", values, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdNotIn(List<Integer> values) {
addCriterion("CD_COUPON_CATEGORY_ID not in", values, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdBetween(Integer value1, Integer value2) {
addCriterion("CD_COUPON_CATEGORY_ID between", value1, value2, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加优惠券分类ID查询条件
public Criteria andCdCouponCategoryIdNotBetween(Integer value1, Integer value2) {
addCriterion("CD_COUPON_CATEGORY_ID not between", value1, value2, "cdCouponCategoryId");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeIsNull() {
addCriterion("REF_TYPE is null");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeIsNotNull() {
addCriterion("REF_TYPE is not null");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeEqualTo(String value) {
addCriterion("REF_TYPE =", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeNotEqualTo(String value) {
addCriterion("REF_TYPE <>", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeGreaterThan(String value) {
addCriterion("REF_TYPE >", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeGreaterThanOrEqualTo(String value) {
addCriterion("REF_TYPE >=", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeLessThan(String value) {
addCriterion("REF_TYPE <", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeLessThanOrEqualTo(String value) {
addCriterion("REF_TYPE <=", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeLike(String value) {
addCriterion("REF_TYPE like", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeNotLike(String value) {
addCriterion("REF_TYPE not like", value, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeIn(List<String> values) {
addCriterion("REF_TYPE in", values, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeNotIn(List<String> values) {
addCriterion("REF_TYPE not in", values, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeBetween(String value1, String value2) {
addCriterion("REF_TYPE between", value1, value2, "refType");
return (Criteria) this;
}
// 添加关联类型查询条件
public Criteria andRefTypeNotBetween(String value1, String value2) {
addCriterion("REF_TYPE not between", value1, value2, "refType");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameIsNull() {
addCriterion("REF_NAME is null");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameIsNotNull() {
addCriterion("REF_NAME is not null");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameEqualTo(String value) {
addCriterion("REF_NAME =", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameNotEqualTo(String value) {
addCriterion("REF_NAME <>", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameGreaterThan(String value) {
addCriterion("REF_NAME >", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameGreaterThanOrEqualTo(String value) {
addCriterion("REF_NAME >=", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameLessThan(String value) {
addCriterion("REF_NAME <", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameLessThanOrEqualTo(String value) {
addCriterion("REF_NAME <=", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameLike(String value) {
addCriterion("REF_NAME like", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameNotLike(String value) {
addCriterion("REF_NAME not like", value, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameIn(List<String> values) {
addCriterion("REF_NAME in", values, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameNotIn(List<String> values) {
addCriterion("REF_NAME not in", values, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameBetween(String value1, String value2) {
addCriterion("REF_NAME between", value1, value2, "refName");
return (Criteria) this;
}
// 添加关联名称查询条件
public Criteria andRefNameNotBetween(String value1, String value2) {
addCriterion("REF_NAME not between", value1, value2, "refName");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueIsNull() {
addCriterion("REF_VALUE is null");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueIsNotNull() {
addCriterion("REF_VALUE is not null");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueEqualTo(String value) {
addCriterion("REF_VALUE =", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueNotEqualTo(String value) {
addCriterion("REF_VALUE <>", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueGreaterThan(String value) {
addCriterion("REF_VALUE >", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueGreaterThanOrEqualTo(String value) {
addCriterion("REF_VALUE >=", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueLessThan(String value) {
addCriterion("REF_VALUE <", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueLessThanOrEqualTo(String value) {
addCriterion("REF_VALUE <=", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueLike(String value) {
addCriterion("REF_VALUE like", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueNotLike(String value) {
addCriterion("REF_VALUE not like", value, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueIn(List<String> values) {
addCriterion("REF_VALUE in", values, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueNotIn(List<String> values) {
addCriterion("REF_VALUE not in", values, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueBetween(String value1, String value2) {
addCriterion("REF_VALUE between", value1, value2, "refValue");
return (Criteria) this;
}
// 添加关联值查询条件
public Criteria andRefValueNotBetween(String value1, String value2) {
addCriterion("REF_VALUE not between", value1, value2, "refValue");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountIsNull() {
addCriterion("REF_COUNT is null");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountIsNotNull() {
addCriterion("REF_COUNT is not null");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountEqualTo(Integer value) {
addCriterion("REF_COUNT =", value, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountNotEqualTo(Integer value) {
addCriterion("REF_COUNT <>", value, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountGreaterThan(Integer value) {
addCriterion("REF_COUNT >", value, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountGreaterThanOrEqualTo(Integer value) {
addCriterion("REF_COUNT >=", value, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountLessThan(Integer value) {
addCriterion("REF_COUNT <", value, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountLessThanOrEqualTo(Integer value) {
addCriterion("REF_COUNT <=", value, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountIn(List<Integer> values) {
addCriterion("REF_COUNT in", values, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountNotIn(List<Integer> values) {
addCriterion("REF_COUNT not in", values, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountBetween(Integer value1, Integer value2) {
addCriterion("REF_COUNT between", value1, value2, "refCount");
return (Criteria) this;
}
// 添加关联数量查询条件
public Criteria andRefCountNotBetween(Integer value1, Integer value2) {
addCriterion("REF_COUNT not between", value1, value2, "refCount");
return (Criteria) this;

298
src/main/java/com/xmomen/module/base/entity/CdCouponExample.java
View File

File diff suppressed because it is too large Load Diff

25
src/main/java/com/xmomen/module/base/entity/CdCouponRef.java
Unescape View File

@ -11,34 +11,23 @@ import javax.persistence.Version;
@Entity
@Table(name = "cd_coupon_ref")
public class CdCouponRef extends BaseMybatisModel {
/**
*
*/
// 主键ID
private Integer id;
/**
* 卡劵
*/
// 优惠券ID
private Integer cdCouponId;
/**
* 卡号
*/
// 优惠券编号
private String couponNumber;
/**
* 拓展类型
*/
// 关联类型
private String refType;
/**
* 拓展描述
*/
// 关联名称
private String refName;
/**
* 拓展值
*/
// 关联值
private String refValue;
@Column(name = "ID")

Write Preview
Loading…
Cancel
Save