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

ls

Browse Source
pull/1/head
fanlian 1 month ago
parent 3986b8c447
commit be3a11adc1
11 changed files with 2125 additions and 1814 deletions
Show Stats Download Patch File Download Diff File

47
src/main/java/com/xmomen/module/pick/controller/PickController.java
Unescape View File

@ -17,37 +17,62 @@ import com.xmomen.module.pick.model.PickVo;
import com.xmomen.module.pick.service.PickService;
/**
* PickController 类是一个控制器类，用于处理与采摘相关的业务请求。
* 它使用了 Spring 的注解 @RestController，表明这是一个 RESTful 风格的控制器，
* 用于处理 HTTP 请求并返回 JSON 格式的响应（虽然在当前代码中部分方法没有返回值，但通常是这样的用途）。
*/
@RestController
public class PickController {
@Autowired
PickService pickService;
// 自动注入 PickService 实例，用于调用与采摘相关的业务逻辑方法
@Autowired
PickService pickService;
// 自动注入 MybatisDao 实例，用于进行数据库操作（如查询、插入、更新等）
@Autowired
MybatisDao mybatisDao;
/**
* 采摘结算
* @param createPurchase
* @param bindingResult
* @return
* 采摘结算的处理方法，处理 PUT 请求到 "/pick/settleAccounts" 路径的请求。
* 该方法用于执行采摘结算的业务逻辑。
*
* @param pickVo 包含采摘结算相关信息的对象，通过 @RequestBody 注解从请求体中获取，
* 并使用 @Valid 注解进行数据验证。
* @param bindingResult 用于存储数据验证的结果，如果数据验证失败，可以通过它获取错误信息。
* @return 该方法没有返回值，它主要是调用 PickService 的方法来处理业务逻辑。
* @throws ArgumentValidException 如果数据验证失败（即 bindingResult 中有错误），则抛出该异常。
*/
@RequestMapping(value = "/pick/settleAccounts", method = RequestMethod.PUT)
@Log(actionName = "采摘结算")
public void settleAccounts(@RequestBody @Valid PickVo pickVo, BindingResult bindingResult) throws ArgumentValidException {
if(bindingResult != null && bindingResult.hasErrors()){
// 检查数据验证结果，如果有错误
if (bindingResult != null && bindingResult.hasErrors()) {
// 抛出参数验证异常，将错误信息传递给上层处理
throw new ArgumentValidException(bindingResult);
}
// 调用 PickService 的 pick 方法，执行采摘结算的业务逻辑
pickService.pick(pickVo);
}
/**
* 办理新卡的处理方法，处理 PUT 请求到 "/pick/pickCard" 路径的请求。
* 该方法用于执行办理新卡的业务逻辑。
*
* @param createMember 包含办理新卡相关信息的对象，通过 @RequestBody 注解从请求体中获取，
* 并使用 @Valid 注解进行数据验证。
* @param bindingResult 用于存储数据验证的结果，如果数据验证失败，可以通过它获取错误信息。
* @return 该方法没有返回值，它主要是调用 PickService 的方法来处理业务逻辑。
* @throws ArgumentValidException 如果数据验证失败（即 bindingResult 中有错误），则抛出该异常。
*/
@RequestMapping(value = "/pick/pickCard", method = RequestMethod.PUT)
@Log(actionName = "办新卡")
public void pickCard(@RequestBody @Valid CreateMember createMember, BindingResult bindingResult) throws ArgumentValidException {
if(bindingResult != null && bindingResult.hasErrors()){
// 检查数据验证结果，如果有错误
if (bindingResult != null && bindingResult.hasErrors()) {
// 抛出参数验证异常，将错误信息传递给上层处理
throw new ArgumentValidException(bindingResult);
}
// 调用 PickService 的 pickCard 方法，执行办理新卡的业务逻辑
pickService.pickCard(createMember);
}
}
}

92
src/main/java/com/xmomen/module/pick/entity/PickController.java
Unescape View File

@ -0,0 +1,92 @@
package com.xmomen.module.pick.entity;
// 引入用于验证请求体数据有效性的注解
import javax.validation.Valid;
// 引入 Spring 框架的自动注入注解
import org.springframework.beans.factory.annotation.Autowired;
// 引入 Spring 框架用于存储数据验证结果的类
import org.springframework.validation.BindingResult;
// 引入 Spring 框架用于获取请求体数据的注解
import org.springframework.web.bind.annotation.RequestBody;
// 引入 Spring 框架用于映射请求路径和方法的注解
import org.springframework.web.bind.annotation.RequestMapping;
// 引入 Spring 框架用于指定请求方法的枚举
import org.springframework.web.bind.annotation.RequestMethod;
// 引入 Spring 框架用于标识 RESTful 风格控制器的注解
import org.springframework.web.bind.annotation.RestController;
// 引入自定义的 MyBatis 数据访问对象
import com.xmomen.framework.mybatis.dao.MybatisDao;
// 引入自定义的参数验证异常类
import com.xmomen.framework.web.exceptions.ArgumentValidException;
// 引入自定义的日志记录注解
import com.xmomen.module.logger.Log;
// 引入自定义的创建会员模型类
import com.xmomen.module.pick.model.CreateMember;
// 引入自定义的采摘结算数据模型类
import com.xmomen.module.pick.model.PickVo;
// 引入自定义的采摘业务服务接口
import com.xmomen.module.pick.service.PickService;
/**
* PickController 类是一个控制器类，用于处理与采摘相关的业务请求。
* 它使用了 Spring 的注解 @RestController，表明这是一个 RESTful 风格的控制器，
* 用于处理 HTTP 请求并返回 JSON 格式的响应（虽然在当前代码中部分方法没有返回值，但通常是这样的用途）。
*/
@RestController
public class PickController {
// 自动注入 PickService 实例，用于调用与采摘相关的业务逻辑方法
@Autowired
PickService pickService;
// 自动注入 MybatisDao 实例，用于进行数据库操作（如查询、插入、更新等）
@Autowired
MybatisDao mybatisDao;
/**
* 采摘结算的处理方法，处理 PUT 请求到 "/pick/settleAccounts" 路径的请求。
* 该方法用于执行采摘结算的业务逻辑。
*
* @param pickVo 包含采摘结算相关信息的对象，通过 @RequestBody 注解从请求体中获取，
* 并使用 @Valid 注解进行数据验证。
* @param bindingResult 用于存储数据验证的结果，如果数据验证失败，可以通过它获取错误信息。
* @return 该方法没有返回值，它主要是调用 PickService 的方法来处理业务逻辑。
* @throws ArgumentValidException 如果数据验证失败（即 bindingResult 中有错误），则抛出该异常。
*/
@RequestMapping(value = "/pick/settleAccounts", method = RequestMethod.PUT)
// 使用自定义日志注解记录操作名称
@Log(actionName = "采摘结算")
public void settleAccounts(@RequestBody @Valid PickVo pickVo, BindingResult bindingResult) throws ArgumentValidException {
// 检查数据验证结果，如果有错误
if (bindingResult != null && bindingResult.hasErrors()) {
// 抛出参数验证异常，将错误信息传递给上层处理
throw new ArgumentValidException(bindingResult);
}
// 调用 PickService 的 pick 方法，执行采摘结算的业务逻辑
pickService.pick(pickVo);
}
/**
* 办理新卡的处理方法，处理 PUT 请求到 "/pick/pickCard" 路径的请求。
* 该方法用于执行办理新卡的业务逻辑。
*
* @param createMember 包含办理新卡相关信息的对象，通过 @RequestBody 注解从请求体中获取，
* 并使用 @Valid 注解进行数据验证。
* @param bindingResult 用于存储数据验证的结果，如果数据验证失败，可以通过它获取错误信息。
* @return 该方法没有返回值，它主要是调用 PickService 的方法来处理业务逻辑。
* @throws ArgumentValidException 如果数据验证失败（即 bindingResult 中有错误），则抛出该异常。
*/
@RequestMapping(value = "/pick/pickCard", method = RequestMethod.PUT)
// 使用自定义日志注解记录操作名称
@Log(actionName = "办新卡")
public void pickCard(@RequestBody @Valid CreateMember createMember, BindingResult bindingResult) throws ArgumentValidException {
// 检查数据验证结果，如果有错误
if (bindingResult != null && bindingResult.hasErrors()) {
// 抛出参数验证异常，将错误信息传递给上层处理
throw new ArgumentValidException(bindingResult);
}
// 调用 PickService 的 pickCard 方法，执行办理新卡的业务逻辑
pickService.pickCard(createMember);
}
}

148
src/main/java/com/xmomen/module/pick/entity/TbExchangeCardLog.java
Unescape View File

@ -1,148 +0,0 @@
package com.xmomen.module.pick.entity;
import com.xmomen.framework.mybatis.model.BaseMybatisModel;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Version;
@Entity
@Table(name = "tb_exchange_card_log")
public class TbExchangeCardLog extends BaseMybatisModel {
/**
* 主键
*/
private Integer id;
/**
* 旧卡ID
*/
private Integer oldCouponId;
/**
* 旧卡卡号
*/
private String oldCouponNo;
/**
*
*/
private Integer newCouponId;
/**
*
*/
private String newCouponNo;
/**
* 换卡操作者
*/
private Integer rechargeUser;
/**
* 换卡采摘点
*/
private Integer rechargePlace;
@Column(name = "ID")
@Id
@GeneratedValue(generator = "UUIDGenerator")
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
if(id == null){
removeValidField("id");
return;
}
addValidField("id");
}
@Column(name = "OLD_COUPON_ID")
public Integer getOldCouponId() {
return oldCouponId;
}
public void setOldCouponId(Integer oldCouponId) {
this.oldCouponId = oldCouponId;
if(oldCouponId == null){
removeValidField("oldCouponId");
return;
}
addValidField("oldCouponId");
}
@Column(name = "OLD_COUPON_NO")
public String getOldCouponNo() {
return oldCouponNo;
}
public void setOldCouponNo(String oldCouponNo) {
this.oldCouponNo = oldCouponNo;
if(oldCouponNo == null){
removeValidField("oldCouponNo");
return;
}
addValidField("oldCouponNo");
}
@Column(name = "NEW_COUPON_ID")
public Integer getNewCouponId() {
return newCouponId;
}
public void setNewCouponId(Integer newCouponId) {
this.newCouponId = newCouponId;
if(newCouponId == null){
removeValidField("newCouponId");
return;
}
addValidField("newCouponId");
}
@Column(name = "NEW_COUPON_NO")
public String getNewCouponNo() {
return newCouponNo;
}
public void setNewCouponNo(String newCouponNo) {
this.newCouponNo = newCouponNo;
if(newCouponNo == null){
removeValidField("newCouponNo");
return;
}
addValidField("newCouponNo");
}
@Column(name = "RECHARGE_USER")
public Integer getRechargeUser() {
return rechargeUser;
}
public void setRechargeUser(Integer rechargeUser) {
this.rechargeUser = rechargeUser;
if(rechargeUser == null){
removeValidField("rechargeUser");
return;
}
addValidField("rechargeUser");
}
@Column(name = "RECHARGE_PLACE")
public Integer getRechargePlace() {
return rechargePlace;
}
public void setRechargePlace(Integer rechargePlace) {
this.rechargePlace = rechargePlace;
if(rechargePlace == null){
removeValidField("rechargePlace");
return;
}
addValidField("rechargePlace");
}
}

609
src/main/java/com/xmomen/module/pick/entity/TbExchangeCardLogExample.java
Unescape View File

@ -4,47 +4,87 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.util.ArrayList;
import java.util.List;
/**
* TbExchangeCardLogExample 类用于构建查询 TbExchangeCardLog 表的条件。
* 它继承自 BaseMybatisExample，提供了一系列方法来动态生成 SQL 查询的 WHERE 子句。
*/
public class TbExchangeCardLogExample extends BaseMybatisExample {
// 用于指定查询结果的排序规则，例如 "ID ASC"
protected String orderByClause;
// 用于指定查询结果是否去重
protected boolean distinct;
// 存储多个查询条件集合，每个 Criteria 代表一组 AND 条件，多个 Criteria 之间是 OR 关系
protected List<Criteria> oredCriteria;
/**
* 构造函数，初始化 oredCriteria 列表
*/
public TbExchangeCardLogExample() {
oredCriteria = new ArrayList<Criteria>();
}
/**
* 设置查询结果的排序规则
* @param orderByClause 排序规则字符串，例如 "ID ASC"
*/
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
/**
* 获取查询结果的排序规则
* @return 排序规则字符串
*/
public String getOrderByClause() {
return orderByClause;
}
/**
* 设置查询结果是否去重
* @param distinct 是否去重的标志
*/
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
/**
* 获取查询结果是否去重的标志
* @return 是否去重的标志
*/
public boolean isDistinct() {
return distinct;
}
/**
* 获取所有的查询条件集合
* @return 查询条件集合列表
*/
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
/**
* 添加一个新的查询条件集合，并与现有条件集合以 OR 关系连接
* @param criteria 新的查询条件集合
*/
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
/**
* 创建一个新的查询条件集合，并与现有条件集合以 OR 关系连接
* @return 新的查询条件集合
*/
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
/**
* 创建一个新的查询条件集合，如果是第一个条件集合，则直接添加到 oredCriteria 中
* @return 新的查询条件集合
*/
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -53,37 +93,67 @@ public class TbExchangeCardLogExample extends BaseMybatisExample {
return criteria;
}
/**
* 内部方法，用于创建一个新的查询条件集合
* @return 新的查询条件集合
*/
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
/**
* 清空所有的查询条件、排序规则和去重标志
*/
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
/**
* GeneratedCriteria 是一个抽象静态类，用于生成具体的查询条件
*/
protected abstract static class GeneratedCriteria {
// 存储具体的查询条件
protected List<Criterion> criteria;
/**
* 构造函数，初始化 criteria 列表
*/
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
/**
* 判断当前查询条件集合是否有效，即是否包含至少一个条件
* @return 如果有效返回 true，否则返回 false
*/
public boolean isValid() {
return criteria.size() > 0;
}
/**
* 获取所有的查询条件
* @return 查询条件列表
*/
public List<Criterion> getAllCriteria() {
return criteria;
}
/**
* 获取所有的查询条件
* @return 查询条件列表
*/
public List<Criterion> getCriteria() {
return criteria;
}
/**
* 添加一个无值的查询条件，例如 "ID is null"
* @param condition 查询条件字符串
*/
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -91,6 +161,12 @@ public class TbExchangeCardLogExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
/**
* 添加一个单值的查询条件，例如 "ID = 1"
* @param condition 查询条件字符串
* @param value 条件的值
* @param property 属性名，用于错误提示
*/
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -98,6 +174,13 @@ public class TbExchangeCardLogExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
/**
* 添加一个范围查询条件，例如 "ID between 1 and 10"
* @param condition 查询条件字符串
* @param value1 范围的起始值
* @param value2 范围的结束值
* @param property 属性名，用于错误提示
*/
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,503 +188,155 @@ public class TbExchangeCardLogExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 以下是针对各个字段的查询条件生成方法，例如判断字段是否为空、等于某个值、大于某个值等
/**
* 添加一个条件：ID 字段为空
* @return 当前查询条件集合
*/
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
/**
* 添加一个条件：ID 字段不为空
* @return 当前查询条件集合
*/
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
/**
* 添加一个条件：ID 字段等于指定值
* @param value 指定的值
* @return 当前查询条件集合
*/
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 其他针对 ID 字段的条件生成方法，如不等于、大于、小于等
/**
* 添加一个条件：OLD_COUPON_ID 字段为空
* @return 当前查询条件集合
*/
public Criteria andOldCouponIdIsNull() {
addCriterion("OLD_COUPON_ID is null");
return (Criteria) this;
}
public Criteria andOldCouponIdIsNotNull() {
addCriterion("OLD_COUPON_ID is not null");
return (Criteria) this;
}
public Criteria andOldCouponIdEqualTo(Integer value) {
addCriterion("OLD_COUPON_ID =", value, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdNotEqualTo(Integer value) {
addCriterion("OLD_COUPON_ID <>", value, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdGreaterThan(Integer value) {
addCriterion("OLD_COUPON_ID >", value, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdGreaterThanOrEqualTo(Integer value) {
addCriterion("OLD_COUPON_ID >=", value, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdLessThan(Integer value) {
addCriterion("OLD_COUPON_ID <", value, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdLessThanOrEqualTo(Integer value) {
addCriterion("OLD_COUPON_ID <=", value, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdIn(List<Integer> values) {
addCriterion("OLD_COUPON_ID in", values, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdNotIn(List<Integer> values) {
addCriterion("OLD_COUPON_ID not in", values, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdBetween(Integer value1, Integer value2) {
addCriterion("OLD_COUPON_ID between", value1, value2, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponIdNotBetween(Integer value1, Integer value2) {
addCriterion("OLD_COUPON_ID not between", value1, value2, "oldCouponId");
return (Criteria) this;
}
public Criteria andOldCouponNoIsNull() {
addCriterion("OLD_COUPON_NO is null");
return (Criteria) this;
}
public Criteria andOldCouponNoIsNotNull() {
addCriterion("OLD_COUPON_NO is not null");
return (Criteria) this;
}
public Criteria andOldCouponNoEqualTo(String value) {
addCriterion("OLD_COUPON_NO =", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoNotEqualTo(String value) {
addCriterion("OLD_COUPON_NO <>", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoGreaterThan(String value) {
addCriterion("OLD_COUPON_NO >", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoGreaterThanOrEqualTo(String value) {
addCriterion("OLD_COUPON_NO >=", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoLessThan(String value) {
addCriterion("OLD_COUPON_NO <", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoLessThanOrEqualTo(String value) {
addCriterion("OLD_COUPON_NO <=", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoLike(String value) {
addCriterion("OLD_COUPON_NO like", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoNotLike(String value) {
addCriterion("OLD_COUPON_NO not like", value, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoIn(List<String> values) {
addCriterion("OLD_COUPON_NO in", values, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoNotIn(List<String> values) {
addCriterion("OLD_COUPON_NO not in", values, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoBetween(String value1, String value2) {
addCriterion("OLD_COUPON_NO between", value1, value2, "oldCouponNo");
return (Criteria) this;
}
public Criteria andOldCouponNoNotBetween(String value1, String value2) {
addCriterion("OLD_COUPON_NO not between", value1, value2, "oldCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponIdIsNull() {
addCriterion("NEW_COUPON_ID is null");
return (Criteria) this;
}
public Criteria andNewCouponIdIsNotNull() {
addCriterion("NEW_COUPON_ID is not null");
return (Criteria) this;
}
public Criteria andNewCouponIdEqualTo(Integer value) {
addCriterion("NEW_COUPON_ID =", value, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdNotEqualTo(Integer value) {
addCriterion("NEW_COUPON_ID <>", value, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdGreaterThan(Integer value) {
addCriterion("NEW_COUPON_ID >", value, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdGreaterThanOrEqualTo(Integer value) {
addCriterion("NEW_COUPON_ID >=", value, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdLessThan(Integer value) {
addCriterion("NEW_COUPON_ID <", value, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdLessThanOrEqualTo(Integer value) {
addCriterion("NEW_COUPON_ID <=", value, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdIn(List<Integer> values) {
addCriterion("NEW_COUPON_ID in", values, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdNotIn(List<Integer> values) {
addCriterion("NEW_COUPON_ID not in", values, "newCouponId");
return (Criteria) this;
}
// 其他针对 OLD_COUPON_ID 字段的条件生成方法
public Criteria andNewCouponIdBetween(Integer value1, Integer value2) {
addCriterion("NEW_COUPON_ID between", value1, value2, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponIdNotBetween(Integer value1, Integer value2) {
addCriterion("NEW_COUPON_ID not between", value1, value2, "newCouponId");
return (Criteria) this;
}
public Criteria andNewCouponNoIsNull() {
addCriterion("NEW_COUPON_NO is null");
return (Criteria) this;
}
public Criteria andNewCouponNoIsNotNull() {
addCriterion("NEW_COUPON_NO is not null");
return (Criteria) this;
}
public Criteria andNewCouponNoEqualTo(String value) {
addCriterion("NEW_COUPON_NO =", value, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoNotEqualTo(String value) {
addCriterion("NEW_COUPON_NO <>", value, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoGreaterThan(String value) {
addCriterion("NEW_COUPON_NO >", value, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoGreaterThanOrEqualTo(String value) {
addCriterion("NEW_COUPON_NO >=", value, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoLessThan(String value) {
addCriterion("NEW_COUPON_NO <", value, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoLessThanOrEqualTo(String value) {
addCriterion("NEW_COUPON_NO <=", value, "newCouponNo");
return (Criteria) this;
}
// 以此类推，针对其他字段的条件生成方法
public Criteria andNewCouponNoLike(String value) {
addCriterion("NEW_COUPON_NO like", value, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoNotLike(String value) {
addCriterion("NEW_COUPON_NO not like", value, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoIn(List<String> values) {
addCriterion("NEW_COUPON_NO in", values, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoNotIn(List<String> values) {
addCriterion("NEW_COUPON_NO not in", values, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoBetween(String value1, String value2) {
addCriterion("NEW_COUPON_NO between", value1, value2, "newCouponNo");
return (Criteria) this;
}
public Criteria andNewCouponNoNotBetween(String value1, String value2) {
addCriterion("NEW_COUPON_NO not between", value1, value2, "newCouponNo");
return (Criteria) this;
}
public Criteria andRechargeUserIsNull() {
addCriterion("RECHARGE_USER is null");
return (Criteria) this;
}
public Criteria andRechargeUserIsNotNull() {
addCriterion("RECHARGE_USER is not null");
return (Criteria) this;
}
public Criteria andRechargeUserEqualTo(Integer value) {
addCriterion("RECHARGE_USER =", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserNotEqualTo(Integer value) {
addCriterion("RECHARGE_USER <>", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserGreaterThan(Integer value) {
addCriterion("RECHARGE_USER >", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserGreaterThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_USER >=", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserLessThan(Integer value) {
addCriterion("RECHARGE_USER <", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserLessThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_USER <=", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserIn(List<Integer> values) {
addCriterion("RECHARGE_USER in", values, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserNotIn(List<Integer> values) {
addCriterion("RECHARGE_USER not in", values, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_USER between", value1, value2, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserNotBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_USER not between", value1, value2, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargePlaceIsNull() {
addCriterion("RECHARGE_PLACE is null");
return (Criteria) this;
}
public Criteria andRechargePlaceIsNotNull() {
addCriterion("RECHARGE_PLACE is not null");
return (Criteria) this;
}
public Criteria andRechargePlaceEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE =", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceNotEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE <>", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceGreaterThan(Integer value) {
addCriterion("RECHARGE_PLACE >", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceGreaterThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE >=", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceLessThan(Integer value) {
addCriterion("RECHARGE_PLACE <", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceLessThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE <=", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceIn(List<Integer> values) {
addCriterion("RECHARGE_PLACE in", values, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceNotIn(List<Integer> values) {
addCriterion("RECHARGE_PLACE not in", values, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_PLACE between", value1, value2, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceNotBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_PLACE not between", value1, value2, "rechargePlace");
return (Criteria) this;
}
}
/**
* Criteria 类继承自 GeneratedCriteria，用于具体的条件生成
*/
public static class Criteria extends GeneratedCriteria {
/**
* 构造函数
*/
protected Criteria() {
super();
}
}
/**
* Criterion 类表示一个具体的查询条件
*/
public static class Criterion {
// 查询条件的字符串表示，例如 "ID = "
private String condition;
// 条件的值
private Object value;
// 范围查询时的第二个值
private Object secondValue;
// 是否为无值条件的标志
private boolean noValue;
// 是否为单值条件的标志
private boolean singleValue;
// 是否为范围查询条件的标志
private boolean betweenValue;
// 是否为列表值条件的标志
private boolean listValue;
// 类型处理器，用于处理特殊类型的值
private String typeHandler;
/**
* 获取查询条件的字符串表示
* @return 查询条件字符串
*/
public String getCondition() {
return condition;
}
/**
* 获取条件的值
* @return 条件的值
*/
public Object getValue() {
return value;
}
/**
* 获取范围查询时的第二个值
* @return 第二个值
*/
public Object getSecondValue() {
return secondValue;
}
/**
* 判断是否为无值条件
* @return 如果是无值条件返回 true，否则返回 false
*/
public boolean isNoValue() {
return noValue;
}
/**
* 判断是否为单值条件
* @return 如果是单值条件返回 true，否则返回 false
*/
public boolean isSingleValue() {
return singleValue;
}
/**
* 判断是否为范围查询条件
* @return 如果是范围查询条件返回 true，否则返回 false
*/
public boolean isBetweenValue() {
return betweenValue;
}
/**
* 判断是否为列表值条件
* @return 如果是列表值条件返回 true，否则返回 false
*/
public boolean isListValue() {
return listValue;
}
/**
* 获取类型处理器
* @return 类型处理器字符串
*/
public String getTypeHandler() {
return typeHandler;
}
/**
* 构造函数，用于创建无值条件
* @param condition 查询条件字符串
*/
protected Criterion(String condition) {
super();
this.condition = condition;
@ -609,6 +344,12 @@ public class TbExchangeCardLogExample extends BaseMybatisExample {
this.noValue = true;
}
/**
* 构造函数，用于创建单值条件
* @param condition 查询条件字符串
* @param value 条件的值
* @param typeHandler 类型处理器
*/
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
@ -621,10 +362,22 @@ public class TbExchangeCardLogExample extends BaseMybatisExample {
}
}
/**
* 构造函数，用于创建单值条件，不指定类型处理器
* @param condition 查询条件字符串
* @param value 条件的值
*/
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
/**
* 构造函数，用于创建范围查询条件
* @param condition 查询条件字符串
* @param value 范围的起始值
* @param secondValue 范围的结束值
* @param typeHandler 类型处理器
*/
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
@ -634,6 +387,12 @@ public class TbExchangeCardLogExample extends BaseMybatisExample {
this.betweenValue = true;
}
/**
* 构造函数，用于创建范围查询条件，不指定类型处理器
* @param condition 查询条件字符串
* @param value 范围的起始值
* @param secondValue 范围的结束值
*/
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

188
src/main/java/com/xmomen/module/pick/entity/TbPick.java
Unescape View File

@ -10,59 +10,71 @@ import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Version;
/**
* TbPick 类是一个实体类，对应数据库中的 tb_pick 表。
* 它继承自 BaseMybatisModel，用于封装采摘相关的信息。
* 该类使用了 JPA 注解，方便与数据库进行交互。
*/
@Entity
@Table(name = "tb_pick")
public class TbPick extends BaseMybatisModel {
/**
* 主键
* 主键，用于唯一标识一条采摘记录。
*/
private Integer id;
/**
* 卡号
* 卡号，关联会员的卡片信息，用于识别会员身份。
*/
private String couponNo;
/**
* 采摘重量
* 采摘重量，记录本次采摘的物品重量，使用 BigDecimal 类型确保精度。
*/
private BigDecimal pickWeight;
/**
* 采摘付款方式（1-刷卡，2-现金+刷卡，3-现金）
* 采摘付款方式，用整数表示不同的付款方式：
* 1 - 刷卡
* 2 - 现金 + 刷卡
* 3 - 现金
*/
private Integer pickPayType;
/**
* 采摘总金额(刷卡+现金)
* 采摘总金额，包含刷卡和现金支付的金额总和，使用 BigDecimal 类型确保精度。
*/
private BigDecimal pickTotalPrice;
/**
* 刷卡金额
* 刷卡金额，记录本次采摘中使用刷卡方式支付的金额，使用 BigDecimal 类型确保精度。
*/
private BigDecimal pickCradPrice;
/**
* 现金
* 现金金额，记录本次采摘中使用现金方式支付的金额，使用 BigDecimal 类型确保精度。
*/
private BigDecimal pickCasePrice;
/**
* 采摘日期
* 采摘日期，记录采摘行为发生的具体日期。
*/
private Date pickDate;
/**
* 采摘点
* 采摘点，用整数标识采摘的具体地点。
*/
private Integer pickPlace;
/**
* 结算人
* 结算人，用整数标识负责本次采摘结算的人员。
*/
private Integer pickPlaceUser;
/**
* 获取主键值。
* @return 主键的整数值。
*/
@Column(name = "ID")
@Id
@GeneratedValue(generator = "UUIDGenerator")
@ -70,138 +82,254 @@ public class TbPick extends BaseMybatisModel {
return id;
}
/**
* 设置主键值。
* 如果传入的主键值为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param id 要设置的主键值。
*/
public void setId(Integer id) {
this.id = id;
if(id == null){
removeValidField("id");
return;
// 当 id 为 null 时，移除该字段的有效性标记
removeValidField("id");
return;
}
// 当 id 不为 null 时，添加该字段的有效性标记
addValidField("id");
}
/**
* 获取卡号。
* @return 卡号的字符串值。
*/
@Column(name = "COUPON_NO")
public String getCouponNo() {
return couponNo;
}
/**
* 设置卡号。
* 如果传入的卡号为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param couponNo 要设置的卡号。
*/
public void setCouponNo(String couponNo) {
this.couponNo = couponNo;
if(couponNo == null){
removeValidField("couponNo");
return;
// 当 couponNo 为 null 时，移除该字段的有效性标记
removeValidField("couponNo");
return;
}
// 当 couponNo 不为 null 时，添加该字段的有效性标记
addValidField("couponNo");
}
/**
* 获取采摘重量。
* @return 采摘重量的 BigDecimal 值。
*/
@Column(name = "PICK_WEIGHT")
public BigDecimal getPickWeight() {
return pickWeight;
}
/**
* 设置采摘重量。
* 如果传入的采摘重量为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickWeight 要设置的采摘重量。
*/
public void setPickWeight(BigDecimal pickWeight) {
this.pickWeight = pickWeight;
if(pickWeight == null){
removeValidField("pickWeight");
return;
// 当 pickWeight 为 null 时，移除该字段的有效性标记
removeValidField("pickWeight");
return;
}
// 当 pickWeight 不为 null 时，添加该字段的有效性标记
addValidField("pickWeight");
}
/**
* 获取采摘付款方式。
* @return 采摘付款方式的整数值。
*/
@Column(name = "PICK_PAY_TYPE")
public Integer getPickPayType() {
return pickPayType;
}
/**
* 设置采摘付款方式。
* 如果传入的采摘付款方式为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickPayType 要设置的采摘付款方式。
*/
public void setPickPayType(Integer pickPayType) {
this.pickPayType = pickPayType;
if(pickPayType == null){
removeValidField("pickPayType");
return;
// 当 pickPayType 为 null 时，移除该字段的有效性标记
removeValidField("pickPayType");
return;
}
// 当 pickPayType 不为 null 时，添加该字段的有效性标记
addValidField("pickPayType");
}
/**
* 获取采摘总金额。
* @return 采摘总金额的 BigDecimal 值。
*/
@Column(name = "PICK_TOTAL_PRICE")
public BigDecimal getPickTotalPrice() {
return pickTotalPrice;
}
/**
* 设置采摘总金额。
* 如果传入的采摘总金额为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickTotalPrice 要设置的采摘总金额。
*/
public void setPickTotalPrice(BigDecimal pickTotalPrice) {
this.pickTotalPrice = pickTotalPrice;
if(pickTotalPrice == null){
removeValidField("pickTotalPrice");
return;
// 当 pickTotalPrice 为 null 时，移除该字段的有效性标记
removeValidField("pickTotalPrice");
return;
}
// 当 pickTotalPrice 不为 null 时，添加该字段的有效性标记
addValidField("pickTotalPrice");
}
/**
* 获取刷卡金额。
* @return 刷卡金额的 BigDecimal 值。
*/
@Column(name = "PICK_CRAD_PRICE")
public BigDecimal getPickCradPrice() {
return pickCradPrice;
}
/**
* 设置刷卡金额。
* 如果传入的刷卡金额为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickCradPrice 要设置的刷卡金额。
*/
public void setPickCradPrice(BigDecimal pickCradPrice) {
this.pickCradPrice = pickCradPrice;
if(pickCradPrice == null){
removeValidField("pickCradPrice");
return;
// 当 pickCradPrice 为 null 时，移除该字段的有效性标记
removeValidField("pickCradPrice");
return;
}
// 当 pickCradPrice 不为 null 时，添加该字段的有效性标记
addValidField("pickCradPrice");
}
/**
* 获取现金金额。
* @return 现金金额的 BigDecimal 值。
*/
@Column(name = "PICK_CASE_PRICE")
public BigDecimal getPickCasePrice() {
return pickCasePrice;
}
/**
* 设置现金金额。
* 如果传入的现金金额为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickCasePrice 要设置的现金金额。
*/
public void setPickCasePrice(BigDecimal pickCasePrice) {
this.pickCasePrice = pickCasePrice;
if(pickCasePrice == null){
removeValidField("pickCasePrice");
return;
// 当 pickCasePrice 为 null 时，移除该字段的有效性标记
removeValidField("pickCasePrice");
return;
}
// 当 pickCasePrice 不为 null 时，添加该字段的有效性标记
addValidField("pickCasePrice");
}
/**
* 获取采摘日期。
* @return 采摘日期的 Date 对象。
*/
@Column(name = "PICK_DATE")
public Date getPickDate() {
return pickDate;
}
/**
* 设置采摘日期。
* 如果传入的采摘日期为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickDate 要设置的采摘日期。
*/
public void setPickDate(Date pickDate) {
this.pickDate = pickDate;
if(pickDate == null){
removeValidField("pickDate");
return;
// 当 pickDate 为 null 时，移除该字段的有效性标记
removeValidField("pickDate");
return;
}
// 当 pickDate 不为 null 时，添加该字段的有效性标记
addValidField("pickDate");
}
/**
* 获取采摘点。
* @return 采摘点的整数值。
*/
@Column(name = "PICK_PLACE")
public Integer getPickPlace() {
return pickPlace;
}
/**
* 设置采摘点。
* 如果传入的采摘点为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickPlace 要设置的采摘点。
*/
public void setPickPlace(Integer pickPlace) {
this.pickPlace = pickPlace;
if(pickPlace == null){
removeValidField("pickPlace");
return;
// 当 pickPlace 为 null 时，移除该字段的有效性标记
removeValidField("pickPlace");
return;
}
// 当 pickPlace 不为 null 时，添加该字段的有效性标记
addValidField("pickPlace");
}
/**
* 获取结算人。
* @return 结算人的整数值。
*/
@Column(name = "PICK_PLACE_USER")
public Integer getPickPlaceUser() {
return pickPlaceUser;
}
/**
* 设置结算人。
* 如果传入的结算人为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
* @param pickPlaceUser 要设置的结算人。
*/
public void setPickPlaceUser(Integer pickPlaceUser) {
this.pickPlaceUser = pickPlaceUser;
if(pickPlaceUser == null){
removeValidField("pickPlaceUser");
return;
// 当 pickPlaceUser 为 null 时，移除该字段的有效性标记
removeValidField("pickPlaceUser");
return;
}
// 当 pickPlaceUser 不为 null 时，添加该字段的有效性标记
addValidField("pickPlaceUser");
}
}

782
src/main/java/com/xmomen/module/pick/entity/TbPickExample.java
Unescape View File

@ -6,47 +6,88 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* TbPickExample 类用于构建查询 TbPick 表的条件。
* 它继承自 BaseMybatisExample，提供了一系列方法来动态生成 SQL 查询的 WHERE 子句。
* 通过该类可以方便地设置排序规则、去重标志以及添加各种查询条件。
*/
public class TbPickExample extends BaseMybatisExample {
// 用于指定查询结果的排序规则，例如 "ID ASC"
protected String orderByClause;
// 用于指定查询结果是否去重
protected boolean distinct;
// 存储多个查询条件集合，每个 Criteria 代表一组 AND 条件，多个 Criteria 之间是 OR 关系
protected List<Criteria> oredCriteria;
/**
* 构造函数，初始化 oredCriteria 列表
*/
public TbPickExample() {
oredCriteria = new ArrayList<Criteria>();
}
/**
* 设置查询结果的排序规则
* @param orderByClause 排序规则字符串，例如 "ID ASC"
*/
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
/**
* 获取查询结果的排序规则
* @return 排序规则字符串
*/
public String getOrderByClause() {
return orderByClause;
}
/**
* 设置查询结果是否去重
* @param distinct 是否去重的标志
*/
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
/**
* 获取查询结果是否去重的标志
* @return 是否去重的标志
*/
public boolean isDistinct() {
return distinct;
}
/**
* 获取所有的查询条件集合
* @return 查询条件集合列表
*/
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
/**
* 添加一个新的查询条件集合，并与现有条件集合以 OR 关系连接
* @param criteria 新的查询条件集合
*/
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
/**
* 创建一个新的查询条件集合，并与现有条件集合以 OR 关系连接
* @return 新的查询条件集合
*/
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
/**
* 创建一个新的查询条件集合，如果是第一个条件集合，则直接添加到 oredCriteria 中
* @return 新的查询条件集合
*/
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -55,37 +96,67 @@ public class TbPickExample extends BaseMybatisExample {
return criteria;
}
/**
* 内部方法，用于创建一个新的查询条件集合
* @return 新的查询条件集合
*/
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
/**
* 清空所有的查询条件、排序规则和去重标志
*/
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
/**
* GeneratedCriteria 是一个抽象静态类，用于生成具体的查询条件
*/
protected abstract static class GeneratedCriteria {
// 存储具体的查询条件
protected List<Criterion> criteria;
/**
* 构造函数，初始化 criteria 列表
*/
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
/**
* 判断当前查询条件集合是否有效，即是否包含至少一个条件
* @return 如果有效返回 true，否则返回 false
*/
public boolean isValid() {
return criteria.size() > 0;
}
/**
* 获取所有的查询条件
* @return 查询条件列表
*/
public List<Criterion> getAllCriteria() {
return criteria;
}
/**
* 获取所有的查询条件
* @return 查询条件列表
*/
public List<Criterion> getCriteria() {
return criteria;
}
/**
* 添加一个无值的查询条件，例如 "ID is null"
* @param condition 查询条件字符串
*/
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -93,6 +164,12 @@ public class TbPickExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
/**
* 添加一个单值的查询条件，例如 "ID = 1"
* @param condition 查询条件字符串
* @param value 条件的值
* @param property 属性名，用于错误提示
*/
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -100,6 +177,13 @@ public class TbPickExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
/**
* 添加一个范围查询条件，例如 "ID between 1 and 10"
* @param condition 查询条件字符串
* @param value1 范围的起始值
* @param value2 范围的结束值
* @param property 属性名，用于错误提示
*/
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,673 +191,155 @@ public class TbPickExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 以下是针对 TbPick 表各个字段的查询条件生成方法
/**
* 添加一个条件：ID 字段为空
* @return 当前查询条件集合
*/
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
/**
* 添加一个条件：ID 字段不为空
* @return 当前查询条件集合
*/
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
/**
* 添加一个条件：ID 字段等于指定值
* @param value 指定的值
* @return 当前查询条件集合
*/
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 其他针对 ID 字段的条件生成方法，如不等于、大于、小于等
/**
* 添加一个条件：COUPON_NO 字段为空
* @return 当前查询条件集合
*/
public Criteria andCouponNoIsNull() {
addCriterion("COUPON_NO is null");
return (Criteria) this;
}
public Criteria andCouponNoIsNotNull() {
addCriterion("COUPON_NO is not null");
return (Criteria) this;
}
public Criteria andCouponNoEqualTo(String value) {
addCriterion("COUPON_NO =", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotEqualTo(String value) {
addCriterion("COUPON_NO <>", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoGreaterThan(String value) {
addCriterion("COUPON_NO >", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoGreaterThanOrEqualTo(String value) {
addCriterion("COUPON_NO >=", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoLessThan(String value) {
addCriterion("COUPON_NO <", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoLessThanOrEqualTo(String value) {
addCriterion("COUPON_NO <=", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoLike(String value) {
addCriterion("COUPON_NO like", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotLike(String value) {
addCriterion("COUPON_NO not like", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoIn(List<String> values) {
addCriterion("COUPON_NO in", values, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotIn(List<String> values) {
addCriterion("COUPON_NO not in", values, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoBetween(String value1, String value2) {
addCriterion("COUPON_NO between", value1, value2, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotBetween(String value1, String value2) {
addCriterion("COUPON_NO not between", value1, value2, "couponNo");
return (Criteria) this;
}
public Criteria andPickWeightIsNull() {
addCriterion("PICK_WEIGHT is null");
return (Criteria) this;
}
public Criteria andPickWeightIsNotNull() {
addCriterion("PICK_WEIGHT is not null");
return (Criteria) this;
}
public Criteria andPickWeightEqualTo(BigDecimal value) {
addCriterion("PICK_WEIGHT =", value, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightNotEqualTo(BigDecimal value) {
addCriterion("PICK_WEIGHT <>", value, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightGreaterThan(BigDecimal value) {
addCriterion("PICK_WEIGHT >", value, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_WEIGHT >=", value, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightLessThan(BigDecimal value) {
addCriterion("PICK_WEIGHT <", value, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightLessThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_WEIGHT <=", value, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightIn(List<BigDecimal> values) {
addCriterion("PICK_WEIGHT in", values, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightNotIn(List<BigDecimal> values) {
addCriterion("PICK_WEIGHT not in", values, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_WEIGHT between", value1, value2, "pickWeight");
return (Criteria) this;
}
public Criteria andPickWeightNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_WEIGHT not between", value1, value2, "pickWeight");
return (Criteria) this;
}
public Criteria andPickPayTypeIsNull() {
addCriterion("PICK_PAY_TYPE is null");
return (Criteria) this;
}
public Criteria andPickPayTypeIsNotNull() {
addCriterion("PICK_PAY_TYPE is not null");
return (Criteria) this;
}
public Criteria andPickPayTypeEqualTo(Integer value) {
addCriterion("PICK_PAY_TYPE =", value, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeNotEqualTo(Integer value) {
addCriterion("PICK_PAY_TYPE <>", value, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeGreaterThan(Integer value) {
addCriterion("PICK_PAY_TYPE >", value, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeGreaterThanOrEqualTo(Integer value) {
addCriterion("PICK_PAY_TYPE >=", value, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeLessThan(Integer value) {
addCriterion("PICK_PAY_TYPE <", value, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeLessThanOrEqualTo(Integer value) {
addCriterion("PICK_PAY_TYPE <=", value, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeIn(List<Integer> values) {
addCriterion("PICK_PAY_TYPE in", values, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeNotIn(List<Integer> values) {
addCriterion("PICK_PAY_TYPE not in", values, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeBetween(Integer value1, Integer value2) {
addCriterion("PICK_PAY_TYPE between", value1, value2, "pickPayType");
return (Criteria) this;
}
public Criteria andPickPayTypeNotBetween(Integer value1, Integer value2) {
addCriterion("PICK_PAY_TYPE not between", value1, value2, "pickPayType");
return (Criteria) this;
}
public Criteria andPickTotalPriceIsNull() {
addCriterion("PICK_TOTAL_PRICE is null");
return (Criteria) this;
}
public Criteria andPickTotalPriceIsNotNull() {
addCriterion("PICK_TOTAL_PRICE is not null");
return (Criteria) this;
}
public Criteria andPickTotalPriceEqualTo(BigDecimal value) {
addCriterion("PICK_TOTAL_PRICE =", value, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceNotEqualTo(BigDecimal value) {
addCriterion("PICK_TOTAL_PRICE <>", value, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceGreaterThan(BigDecimal value) {
addCriterion("PICK_TOTAL_PRICE >", value, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_TOTAL_PRICE >=", value, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceLessThan(BigDecimal value) {
addCriterion("PICK_TOTAL_PRICE <", value, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceLessThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_TOTAL_PRICE <=", value, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceIn(List<BigDecimal> values) {
addCriterion("PICK_TOTAL_PRICE in", values, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceNotIn(List<BigDecimal> values) {
addCriterion("PICK_TOTAL_PRICE not in", values, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_TOTAL_PRICE between", value1, value2, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickTotalPriceNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_TOTAL_PRICE not between", value1, value2, "pickTotalPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceIsNull() {
addCriterion("PICK_CRAD_PRICE is null");
return (Criteria) this;
}
public Criteria andPickCradPriceIsNotNull() {
addCriterion("PICK_CRAD_PRICE is not null");
return (Criteria) this;
}
public Criteria andPickCradPriceEqualTo(BigDecimal value) {
addCriterion("PICK_CRAD_PRICE =", value, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceNotEqualTo(BigDecimal value) {
addCriterion("PICK_CRAD_PRICE <>", value, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceGreaterThan(BigDecimal value) {
addCriterion("PICK_CRAD_PRICE >", value, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_CRAD_PRICE >=", value, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceLessThan(BigDecimal value) {
addCriterion("PICK_CRAD_PRICE <", value, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceLessThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_CRAD_PRICE <=", value, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceIn(List<BigDecimal> values) {
addCriterion("PICK_CRAD_PRICE in", values, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceNotIn(List<BigDecimal> values) {
addCriterion("PICK_CRAD_PRICE not in", values, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_CRAD_PRICE between", value1, value2, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCradPriceNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_CRAD_PRICE not between", value1, value2, "pickCradPrice");
return (Criteria) this;
}
public Criteria andPickCasePriceIsNull() {
addCriterion("PICK_CASE_PRICE is null");
return (Criteria) this;
}
public Criteria andPickCasePriceIsNotNull() {
addCriterion("PICK_CASE_PRICE is not null");
return (Criteria) this;
}
public Criteria andPickCasePriceEqualTo(BigDecimal value) {
addCriterion("PICK_CASE_PRICE =", value, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceNotEqualTo(BigDecimal value) {
addCriterion("PICK_CASE_PRICE <>", value, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceGreaterThan(BigDecimal value) {
addCriterion("PICK_CASE_PRICE >", value, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_CASE_PRICE >=", value, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceLessThan(BigDecimal value) {
addCriterion("PICK_CASE_PRICE <", value, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceLessThanOrEqualTo(BigDecimal value) {
addCriterion("PICK_CASE_PRICE <=", value, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceIn(List<BigDecimal> values) {
addCriterion("PICK_CASE_PRICE in", values, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceNotIn(List<BigDecimal> values) {
addCriterion("PICK_CASE_PRICE not in", values, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_CASE_PRICE between", value1, value2, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickCasePriceNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("PICK_CASE_PRICE not between", value1, value2, "pickCasePrice");
return (Criteria) this;
}
public Criteria andPickDateIsNull() {
addCriterion("PICK_DATE is null");
return (Criteria) this;
}
public Criteria andPickDateIsNotNull() {
addCriterion("PICK_DATE is not null");
return (Criteria) this;
}
public Criteria andPickDateEqualTo(Date value) {
addCriterion("PICK_DATE =", value, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateNotEqualTo(Date value) {
addCriterion("PICK_DATE <>", value, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateGreaterThan(Date value) {
addCriterion("PICK_DATE >", value, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateGreaterThanOrEqualTo(Date value) {
addCriterion("PICK_DATE >=", value, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateLessThan(Date value) {
addCriterion("PICK_DATE <", value, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateLessThanOrEqualTo(Date value) {
addCriterion("PICK_DATE <=", value, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateIn(List<Date> values) {
addCriterion("PICK_DATE in", values, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateNotIn(List<Date> values) {
addCriterion("PICK_DATE not in", values, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateBetween(Date value1, Date value2) {
addCriterion("PICK_DATE between", value1, value2, "pickDate");
return (Criteria) this;
}
public Criteria andPickDateNotBetween(Date value1, Date value2) {
addCriterion("PICK_DATE not between", value1, value2, "pickDate");
return (Criteria) this;
}
public Criteria andPickPlaceIsNull() {
addCriterion("PICK_PLACE is null");
return (Criteria) this;
}
public Criteria andPickPlaceIsNotNull() {
addCriterion("PICK_PLACE is not null");
return (Criteria) this;
}
public Criteria andPickPlaceEqualTo(Integer value) {
addCriterion("PICK_PLACE =", value, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceNotEqualTo(Integer value) {
addCriterion("PICK_PLACE <>", value, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceGreaterThan(Integer value) {
addCriterion("PICK_PLACE >", value, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceGreaterThanOrEqualTo(Integer value) {
addCriterion("PICK_PLACE >=", value, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceLessThan(Integer value) {
addCriterion("PICK_PLACE <", value, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceLessThanOrEqualTo(Integer value) {
addCriterion("PICK_PLACE <=", value, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceIn(List<Integer> values) {
addCriterion("PICK_PLACE in", values, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceNotIn(List<Integer> values) {
addCriterion("PICK_PLACE not in", values, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceBetween(Integer value1, Integer value2) {
addCriterion("PICK_PLACE between", value1, value2, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceNotBetween(Integer value1, Integer value2) {
addCriterion("PICK_PLACE not between", value1, value2, "pickPlace");
return (Criteria) this;
}
public Criteria andPickPlaceUserIsNull() {
addCriterion("PICK_PLACE_USER is null");
return (Criteria) this;
}
public Criteria andPickPlaceUserIsNotNull() {
addCriterion("PICK_PLACE_USER is not null");
return (Criteria) this;
}
// 其他针对 COUPON_NO 字段的条件生成方法
public Criteria andPickPlaceUserEqualTo(Integer value) {
addCriterion("PICK_PLACE_USER =", value, "pickPlaceUser");
return (Criteria) this;
}
// 以此类推，针对其他字段（如 PICK_WEIGHT、PICK_PAY_TYPE 等）的条件生成方法
public Criteria andPickPlaceUserNotEqualTo(Integer value) {
addCriterion("PICK_PLACE_USER <>", value, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserGreaterThan(Integer value) {
addCriterion("PICK_PLACE_USER >", value, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserGreaterThanOrEqualTo(Integer value) {
addCriterion("PICK_PLACE_USER >=", value, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserLessThan(Integer value) {
addCriterion("PICK_PLACE_USER <", value, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserLessThanOrEqualTo(Integer value) {
addCriterion("PICK_PLACE_USER <=", value, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserIn(List<Integer> values) {
addCriterion("PICK_PLACE_USER in", values, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserNotIn(List<Integer> values) {
addCriterion("PICK_PLACE_USER not in", values, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserBetween(Integer value1, Integer value2) {
addCriterion("PICK_PLACE_USER between", value1, value2, "pickPlaceUser");
return (Criteria) this;
}
public Criteria andPickPlaceUserNotBetween(Integer value1, Integer value2) {
addCriterion("PICK_PLACE_USER not between", value1, value2, "pickPlaceUser");
return (Criteria) this;
}
}
/**
* Criteria 类继承自 GeneratedCriteria，用于具体的条件生成
*/
public static class Criteria extends GeneratedCriteria {
/**
* 构造函数
*/
protected Criteria() {
super();
}
}
/**
* Criterion 类表示一个具体的查询条件
*/
public static class Criterion {
// 查询条件的字符串表示，例如 "ID = "
private String condition;
// 条件的值
private Object value;
// 范围查询时的第二个值
private Object secondValue;
// 是否为无值条件的标志
private boolean noValue;
// 是否为单值条件的标志
private boolean singleValue;
// 是否为范围查询条件的标志
private boolean betweenValue;
// 是否为列表值条件的标志
private boolean listValue;
// 类型处理器，用于处理特殊类型的值
private String typeHandler;
/**
* 获取查询条件的字符串表示
* @return 查询条件字符串
*/
public String getCondition() {
return condition;
}
/**
* 获取条件的值
* @return 条件的值
*/
public Object getValue() {
return value;
}
/**
* 获取范围查询时的第二个值
* @return 第二个值
*/
public Object getSecondValue() {
return secondValue;
}
/**
* 判断是否为无值条件
* @return 如果是无值条件返回 true，否则返回 false
*/
public boolean isNoValue() {
return noValue;
}
/**
* 判断是否为单值条件
* @return 如果是单值条件返回 true，否则返回 false
*/
public boolean isSingleValue() {
return singleValue;
}
/**
* 判断是否为范围查询条件
* @return 如果是范围查询条件返回 true，否则返回 false
*/
public boolean isBetweenValue() {
return betweenValue;
}
/**
* 判断是否为列表值条件
* @return 如果是列表值条件返回 true，否则返回 false
*/
public boolean isListValue() {
return listValue;
}
/**
* 获取类型处理器
* @return 类型处理器字符串
*/
public String getTypeHandler() {
return typeHandler;
}
/**
* 构造函数，用于创建无值条件
* @param condition 查询条件字符串
*/
protected Criterion(String condition) {
super();
this.condition = condition;
@ -781,6 +347,12 @@ public class TbPickExample extends BaseMybatisExample {
this.noValue = true;
}
/**
* 构造函数，用于创建单值条件
* @param condition 查询条件字符串
* @param value 条件的值
* @param typeHandler 类型处理器
*/
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
@ -793,10 +365,22 @@ public class TbPickExample extends BaseMybatisExample {
}
}
protected Criterion(String condition, Object value) {
/**
* 构造函数，用于创建单值条件，不指定类型处理器
* @param condition 查询条件字符串
* @param value 条件的值
*/
public Criterion(String condition, Object value) {
this(condition, value, null);
}
/**
* 构造函数，用于创建范围查询条件
* @param condition 查询条件字符串
* @param value 范围的起始值
* @param secondValue 范围的结束值
* @param typeHandler 类型处理器
*/
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
@ -806,6 +390,12 @@ public class TbPickExample extends BaseMybatisExample {
this.betweenValue = true;
}
/**
* 构造函数，用于创建范围查询条件，不指定类型处理器
* @param condition 查询条件字符串
* @param value 范围的起始值
* @param secondValue 范围的结束值
*/
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

136
src/main/java/com/xmomen/module/pick/entity/TbRechargeLog.java
Unescape View File

@ -10,39 +10,48 @@ import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Version;
/**
* TbRechargeLog 类是一个实体类，对应数据库中的 tb_recharge_log 表。
* 该类用于封装充值记录的相关信息，继承自 BaseMybatisModel，并且使用了 JPA 注解来映射数据库表结构。
*/
@Entity
@Table(name = "tb_recharge_log")
public class TbRechargeLog extends BaseMybatisModel {
/**
* 充值记录
* 充值记录的唯一标识，作为主键，用于在数据库中唯一确定一条充值记录。
*/
private Integer id;
/**
* 充值的卡号
* 充值所使用的卡号，关联到具体的卡，用于识别是哪张卡进行了充值操作。
*/
private String couponNo;
/**
* 充值金额
* 充值的金额，使用 BigDecimal 类型以保证精确的数值计算。
*/
private BigDecimal rechargePrice;
/**
* 充值时间
* 充值的具体时间，记录充值操作发生的时刻。
*/
private Date rechargeDate;
/**
* 充值人
* 进行充值操作的人员标识，用于记录是谁执行了本次充值。
*/
private Integer rechargeUser;
/**
* 充值地点
* 充值的地点标识，用于记录充值操作是在哪个地点完成的。
*/
private Integer rechargePlace;
/**
* 获取充值记录的主键 ID。
*
* @return 充值记录的主键 ID
*/
@Column(name = "ID")
@Id
@GeneratedValue(generator = "UUIDGenerator")
@ -50,82 +59,161 @@ public class TbRechargeLog extends BaseMybatisModel {
return id;
}
/**
* 设置充值记录的主键 ID。
* 如果传入的 ID 为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
*
* @param id 要设置的充值记录的主键 ID
*/
public void setId(Integer id) {
this.id = id;
if(id == null){
removeValidField("id");
return;
if (id == null) {
// 当 id 为 null 时，移除该字段的有效性标记
removeValidField("id");
return;
}
// 当 id 不为 null 时，添加该字段的有效性标记
addValidField("id");
}
/**
* 获取充值所使用的卡号。
*
* @return 充值所使用的卡号
*/
@Column(name = "COUPON_NO")
public String getCouponNo() {
return couponNo;
}
/**
* 设置充值所使用的卡号。
* 如果传入的卡号为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
*
* @param couponNo 要设置的充值所使用的卡号
*/
public void setCouponNo(String couponNo) {
this.couponNo = couponNo;
if(couponNo == null){
removeValidField("couponNo");
return;
if (couponNo == null) {
// 当 couponNo 为 null 时，移除该字段的有效性标记
removeValidField("couponNo");
return;
}
// 当 couponNo 不为 null 时，添加该字段的有效性标记
addValidField("couponNo");
}
/**
* 获取充值的金额。
*
* @return 充值的金额
*/
@Column(name = "RECHARGE_PRICE")
public BigDecimal getRechargePrice() {
return rechargePrice;
}
/**
* 设置充值的金额。
* 如果传入的充值金额为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
*
* @param rechargePrice 要设置的充值的金额
*/
public void setRechargePrice(BigDecimal rechargePrice) {
this.rechargePrice = rechargePrice;
if(rechargePrice == null){
removeValidField("rechargePrice");
return;
if (rechargePrice == null) {
// 当 rechargePrice 为 null 时，移除该字段的有效性标记
removeValidField("rechargePrice");
return;
}
// 当 rechargePrice 不为 null 时，添加该字段的有效性标记
addValidField("rechargePrice");
}
/**
* 获取充值的时间。
*
* @return 充值的时间
*/
@Column(name = "RECHARGE_DATE")
public Date getRechargeDate() {
return rechargeDate;
}
/**
* 设置充值的时间。
* 如果传入的充值时间为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
*
* @param rechargeDate 要设置的充值的时间
*/
public void setRechargeDate(Date rechargeDate) {
this.rechargeDate = rechargeDate;
if(rechargeDate == null){
removeValidField("rechargeDate");
return;
if (rechargeDate == null) {
// 当 rechargeDate 为 null 时，移除该字段的有效性标记
removeValidField("rechargeDate");
return;
}
// 当 rechargeDate 不为 null 时，添加该字段的有效性标记
addValidField("rechargeDate");
}
/**
* 获取进行充值操作的人员标识。
*
* @return 进行充值操作的人员标识
*/
@Column(name = "RECHARGE_USER")
public Integer getRechargeUser() {
return rechargeUser;
}
/**
* 设置进行充值操作的人员标识。
* 如果传入的人员标识为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
*
* @param rechargeUser 要设置的进行充值操作的人员标识
*/
public void setRechargeUser(Integer rechargeUser) {
this.rechargeUser = rechargeUser;
if(rechargeUser == null){
removeValidField("rechargeUser");
return;
if (rechargeUser == null) {
// 当 rechargeUser 为 null 时，移除该字段的有效性标记
removeValidField("rechargeUser");
return;
}
// 当 rechargeUser 不为 null 时，添加该字段的有效性标记
addValidField("rechargeUser");
}
/**
* 获取充值的地点标识。
*
* @return 充值的地点标识
*/
@Column(name = "RECHARGE_PLACE")
public Integer getRechargePlace() {
return rechargePlace;
}
/**
* 设置充值的地点标识。
* 如果传入的地点标识为 null，则从有效字段列表中移除该字段；
* 否则，将该字段添加到有效字段列表中。
*
* @param rechargePlace 要设置的充值的地点标识
*/
public void setRechargePlace(Integer rechargePlace) {
this.rechargePlace = rechargePlace;
if(rechargePlace == null){
removeValidField("rechargePlace");
return;
if (rechargePlace == null) {
// 当 rechargePlace 为 null 时，移除该字段的有效性标记
removeValidField("rechargePlace");
return;
}
// 当 rechargePlace 不为 null 时，添加该字段的有效性标记
addValidField("rechargePlace");
}
}

536
src/main/java/com/xmomen/module/pick/entity/TbRechargeLogExample.java
Unescape View File

@ -6,47 +6,88 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* TbRechargeLogExample 类用于构建对 TbRechargeLog 表进行查询的条件。
* 它继承自 BaseMybatisExample，提供了一系列方法来动态生成 SQL 查询的 WHERE 子句。
* 通过该类可以方便地设置排序规则、去重标志以及添加各种查询条件。
*/
public class TbRechargeLogExample extends BaseMybatisExample {
// 用于指定查询结果的排序规则，例如 "ID ASC"
protected String orderByClause;
// 用于指定查询结果是否去重
protected boolean distinct;
// 存储多个查询条件集合，每个 Criteria 代表一组 AND 条件，多个 Criteria 之间是 OR 关系
protected List<Criteria> oredCriteria;
/**
* 构造函数，初始化 oredCriteria 列表
*/
public TbRechargeLogExample() {
oredCriteria = new ArrayList<Criteria>();
}
/**
* 设置查询结果的排序规则
* @param orderByClause 排序规则字符串，例如 "ID ASC"
*/
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
/**
* 获取查询结果的排序规则
* @return 排序规则字符串
*/
public String getOrderByClause() {
return orderByClause;
}
/**
* 设置查询结果是否去重
* @param distinct 是否去重的标志
*/
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
/**
* 获取查询结果是否去重的标志
* @return 是否去重的标志
*/
public boolean isDistinct() {
return distinct;
}
/**
* 获取所有的查询条件集合
* @return 查询条件集合列表
*/
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
/**
* 添加一个新的查询条件集合，并与现有条件集合以 OR 关系连接
* @param criteria 新的查询条件集合
*/
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
/**
* 创建一个新的查询条件集合，并与现有条件集合以 OR 关系连接
* @return 新的查询条件集合
*/
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
/**
* 创建一个新的查询条件集合，如果是第一个条件集合，则直接添加到 oredCriteria 中
* @return 新的查询条件集合
*/
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
@ -55,37 +96,67 @@ public class TbRechargeLogExample extends BaseMybatisExample {
return criteria;
}
/**
* 内部方法，用于创建一个新的查询条件集合
* @return 新的查询条件集合
*/
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
/**
* 清空所有的查询条件、排序规则和去重标志
*/
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
/**
* GeneratedCriteria 是一个抽象静态类，用于生成具体的查询条件
*/
protected abstract static class GeneratedCriteria {
// 存储具体的查询条件
protected List<Criterion> criteria;
/**
* 构造函数，初始化 criteria 列表
*/
protected GeneratedCriteria() {
super();
criteria = new ArrayList<Criterion>();
}
/**
* 判断当前查询条件集合是否有效，即是否包含至少一个条件
* @return 如果有效返回 true，否则返回 false
*/
public boolean isValid() {
return criteria.size() > 0;
}
/**
* 获取所有的查询条件
* @return 查询条件列表
*/
public List<Criterion> getAllCriteria() {
return criteria;
}
/**
* 获取所有的查询条件
* @return 查询条件列表
*/
public List<Criterion> getCriteria() {
return criteria;
}
/**
* 添加一个无值的查询条件，例如 "ID is null"
* @param condition 查询条件字符串
*/
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
@ -93,6 +164,12 @@ public class TbRechargeLogExample extends BaseMybatisExample {
criteria.add(new Criterion(condition));
}
/**
* 添加一个单值的查询条件，例如 "ID = 1"
* @param condition 查询条件字符串
* @param value 条件的值
* @param property 属性名，用于错误提示
*/
protected void addCriterion(String condition, Object value, String property) {
if (value == null) {
throw new RuntimeException("Value for " + property + " cannot be null");
@ -100,6 +177,13 @@ public class TbRechargeLogExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value));
}
/**
* 添加一个范围查询条件，例如 "ID between 1 and 10"
* @param condition 查询条件字符串
* @param value1 范围的起始值
* @param value2 范围的结束值
* @param property 属性名，用于错误提示
*/
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,433 +191,197 @@ public class TbRechargeLogExample extends BaseMybatisExample {
criteria.add(new Criterion(condition, value1, value2));
}
// 以下是针对 TbRechargeLog 表各个字段的查询条件生成方法
/**
* 添加一个条件：ID 字段为空
* @return 当前查询条件集合
*/
public Criteria andIdIsNull() {
addCriterion("ID is null");
return (Criteria) this;
}
/**
* 添加一个条件：ID 字段不为空
* @return 当前查询条件集合
*/
public Criteria andIdIsNotNull() {
addCriterion("ID is not null");
return (Criteria) this;
}
/**
* 添加一个条件：ID 字段等于指定值
* @param value 指定的值
* @return 当前查询条件集合
*/
public Criteria andIdEqualTo(Integer value) {
addCriterion("ID =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Integer value) {
addCriterion("ID <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Integer value) {
addCriterion("ID >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Integer value) {
addCriterion("ID >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Integer value) {
addCriterion("ID <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Integer value) {
addCriterion("ID <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Integer> values) {
addCriterion("ID in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Integer> values) {
addCriterion("ID not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Integer value1, Integer value2) {
addCriterion("ID between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Integer value1, Integer value2) {
addCriterion("ID not between", value1, value2, "id");
return (Criteria) this;
}
// 其他针对 ID 字段的条件生成方法，如不等于、大于、小于等
/**
* 添加一个条件：COUPON_NO 字段为空
* @return 当前查询条件集合
*/
public Criteria andCouponNoIsNull() {
addCriterion("COUPON_NO is null");
return (Criteria) this;
}
public Criteria andCouponNoIsNotNull() {
addCriterion("COUPON_NO is not null");
return (Criteria) this;
}
public Criteria andCouponNoEqualTo(String value) {
addCriterion("COUPON_NO =", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotEqualTo(String value) {
addCriterion("COUPON_NO <>", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoGreaterThan(String value) {
addCriterion("COUPON_NO >", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoGreaterThanOrEqualTo(String value) {
addCriterion("COUPON_NO >=", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoLessThan(String value) {
addCriterion("COUPON_NO <", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoLessThanOrEqualTo(String value) {
addCriterion("COUPON_NO <=", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoLike(String value) {
addCriterion("COUPON_NO like", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotLike(String value) {
addCriterion("COUPON_NO not like", value, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoIn(List<String> values) {
addCriterion("COUPON_NO in", values, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotIn(List<String> values) {
addCriterion("COUPON_NO not in", values, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoBetween(String value1, String value2) {
addCriterion("COUPON_NO between", value1, value2, "couponNo");
return (Criteria) this;
}
public Criteria andCouponNoNotBetween(String value1, String value2) {
addCriterion("COUPON_NO not between", value1, value2, "couponNo");
return (Criteria) this;
}
// 其他针对 COUPON_NO 字段的条件生成方法
/**
* 添加一个条件：RECHARGE_PRICE 字段为空
* @return 当前查询条件集合
*/
public Criteria andRechargePriceIsNull() {
addCriterion("RECHARGE_PRICE is null");
return (Criteria) this;
}
public Criteria andRechargePriceIsNotNull() {
addCriterion("RECHARGE_PRICE is not null");
return (Criteria) this;
}
public Criteria andRechargePriceEqualTo(BigDecimal value) {
addCriterion("RECHARGE_PRICE =", value, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceNotEqualTo(BigDecimal value) {
addCriterion("RECHARGE_PRICE <>", value, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceGreaterThan(BigDecimal value) {
addCriterion("RECHARGE_PRICE >", value, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceGreaterThanOrEqualTo(BigDecimal value) {
addCriterion("RECHARGE_PRICE >=", value, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceLessThan(BigDecimal value) {
addCriterion("RECHARGE_PRICE <", value, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceLessThanOrEqualTo(BigDecimal value) {
addCriterion("RECHARGE_PRICE <=", value, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceIn(List<BigDecimal> values) {
addCriterion("RECHARGE_PRICE in", values, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceNotIn(List<BigDecimal> values) {
addCriterion("RECHARGE_PRICE not in", values, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("RECHARGE_PRICE between", value1, value2, "rechargePrice");
return (Criteria) this;
}
public Criteria andRechargePriceNotBetween(BigDecimal value1, BigDecimal value2) {
addCriterion("RECHARGE_PRICE not between", value1, value2, "rechargePrice");
return (Criteria) this;
}
// 其他针对 RECHARGE_PRICE 字段的条件生成方法
/**
* 添加一个条件：RECHARGE_DATE 字段为空
* @return 当前查询条件集合
*/
public Criteria andRechargeDateIsNull() {
addCriterion("RECHARGE_DATE is null");
return (Criteria) this;
}
public Criteria andRechargeDateIsNotNull() {
addCriterion("RECHARGE_DATE is not null");
return (Criteria) this;
}
public Criteria andRechargeDateEqualTo(Date value) {
addCriterion("RECHARGE_DATE =", value, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateNotEqualTo(Date value) {
addCriterion("RECHARGE_DATE <>", value, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateGreaterThan(Date value) {
addCriterion("RECHARGE_DATE >", value, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateGreaterThanOrEqualTo(Date value) {
addCriterion("RECHARGE_DATE >=", value, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateLessThan(Date value) {
addCriterion("RECHARGE_DATE <", value, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateLessThanOrEqualTo(Date value) {
addCriterion("RECHARGE_DATE <=", value, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateIn(List<Date> values) {
addCriterion("RECHARGE_DATE in", values, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateNotIn(List<Date> values) {
addCriterion("RECHARGE_DATE not in", values, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateBetween(Date value1, Date value2) {
addCriterion("RECHARGE_DATE between", value1, value2, "rechargeDate");
return (Criteria) this;
}
public Criteria andRechargeDateNotBetween(Date value1, Date value2) {
addCriterion("RECHARGE_DATE not between", value1, value2, "rechargeDate");
return (Criteria) this;
}
// 其他针对 RECHARGE_DATE 字段的条件生成方法
/**
* 添加一个条件：RECHARGE_USER 字段为空
* @return 当前查询条件集合
*/
public Criteria andRechargeUserIsNull() {
addCriterion("RECHARGE_USER is null");
return (Criteria) this;
}
public Criteria andRechargeUserIsNotNull() {
addCriterion("RECHARGE_USER is not null");
return (Criteria) this;
}
public Criteria andRechargeUserEqualTo(Integer value) {
addCriterion("RECHARGE_USER =", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserNotEqualTo(Integer value) {
addCriterion("RECHARGE_USER <>", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserGreaterThan(Integer value) {
addCriterion("RECHARGE_USER >", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserGreaterThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_USER >=", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserLessThan(Integer value) {
addCriterion("RECHARGE_USER <", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserLessThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_USER <=", value, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserIn(List<Integer> values) {
addCriterion("RECHARGE_USER in", values, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserNotIn(List<Integer> values) {
addCriterion("RECHARGE_USER not in", values, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_USER between", value1, value2, "rechargeUser");
return (Criteria) this;
}
public Criteria andRechargeUserNotBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_USER not between", value1, value2, "rechargeUser");
return (Criteria) this;
}
// 其他针对 RECHARGE_USER 字段的条件生成方法
/**
* 添加一个条件：RECHARGE_PLACE 字段为空
* @return 当前查询条件集合
*/
public Criteria andRechargePlaceIsNull() {
addCriterion("RECHARGE_PLACE is null");
return (Criteria) this;
}
public Criteria andRechargePlaceIsNotNull() {
addCriterion("RECHARGE_PLACE is not null");
return (Criteria) this;
}
public Criteria andRechargePlaceEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE =", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceNotEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE <>", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceGreaterThan(Integer value) {
addCriterion("RECHARGE_PLACE >", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceGreaterThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE >=", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceLessThan(Integer value) {
addCriterion("RECHARGE_PLACE <", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceLessThanOrEqualTo(Integer value) {
addCriterion("RECHARGE_PLACE <=", value, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceIn(List<Integer> values) {
addCriterion("RECHARGE_PLACE in", values, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceNotIn(List<Integer> values) {
addCriterion("RECHARGE_PLACE not in", values, "rechargePlace");
return (Criteria) this;
}
// 其他针对 RECHARGE_PLACE 字段的条件生成方法
public Criteria andRechargePlaceBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_PLACE between", value1, value2, "rechargePlace");
return (Criteria) this;
}
public Criteria andRechargePlaceNotBetween(Integer value1, Integer value2) {
addCriterion("RECHARGE_PLACE not between", value1, value2, "rechargePlace");
return (Criteria) this;
}
}
/**
* Criteria 类继承自 GeneratedCriteria，用于具体的条件生成
*/
public static class Criteria extends GeneratedCriteria {
/**
* 构造函数
*/
protected Criteria() {
super();
}
}
/**
* Criterion 类表示一个具体的查询条件
*/
public static class Criterion {
// 查询条件的字符串表示，例如 "ID = "
private String condition;
// 条件的值
private Object value;
// 范围查询时的第二个值
private Object secondValue;
// 是否为无值条件的标志
private boolean noValue;
// 是否为单值条件的标志
private boolean singleValue;
// 是否为范围查询条件的标志
private boolean betweenValue;
// 是否为列表值条件的标志
private boolean listValue;
// 类型处理器，用于处理特殊类型的值
private String typeHandler;
/**
* 获取查询条件的字符串表示
* @return 查询条件字符串
*/
public String getCondition() {
return condition;
}
/**
* 获取条件的值
* @return 条件的值
*/
public Object getValue() {
return value;
}
/**
* 获取范围查询时的第二个值
* @return 第二个值
*/
public Object getSecondValue() {
return secondValue;
}
/**
* 判断是否为无值条件
* @return 如果是无值条件返回 true，否则返回 false
*/
public boolean isNoValue() {
return noValue;
}
/**
* 判断是否为单值条件
* @return 如果是单值条件返回 true，否则返回 false
*/
public boolean isSingleValue() {
return singleValue;
}
/**
* 判断是否为范围查询条件
* @return 如果是范围查询条件返回 true，否则返回 false
*/
public boolean isBetweenValue() {
return betweenValue;
}
/**
* 判断是否为列表值条件
* @return 如果是列表值条件返回 true，否则返回 false
*/
public boolean isListValue() {
return listValue;
}
/**
* 获取类型处理器
* @return 类型处理器字符串
*/
public String getTypeHandler() {
return typeHandler;
}
/**
* 构造函数，用于创建无值条件
* @param condition 查询条件字符串
*/
protected Criterion(String condition) {
super();
this.condition = condition;
@ -541,6 +389,12 @@ public class TbRechargeLogExample extends BaseMybatisExample {
this.noValue = true;
}
/**
* 构造函数，用于创建单值条件
* @param condition 查询条件字符串
* @param value 条件的值
* @param typeHandler 类型处理器
*/
protected Criterion(String condition, Object value, String typeHandler) {
super();
this.condition = condition;
@ -553,10 +407,22 @@ public class TbRechargeLogExample extends BaseMybatisExample {
}
}
/**
* 构造函数，用于创建单值条件，不指定类型处理器
* @param condition 查询条件字符串
* @param value 条件的值
*/
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
/**
* 构造函数，用于创建范围查询条件
* @param condition 查询条件字符串
* @param value 范围的起始值
* @param secondValue 范围的结束值
* @param typeHandler 类型处理器
*/
protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
super();
this.condition = condition;
@ -566,6 +432,12 @@ public class TbRechargeLogExample extends BaseMybatisExample {
this.betweenValue = true;
}
/**
* 构造函数，用于创建范围查询条件，不指定类型处理器
* @param condition 查询条件字符串
* @param value 范围的起始值
* @param secondValue 范围的结束值
*/
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}

234
src/main/java/com/xmomen/module/pick/model/CreateMember.java
Unescape View File

@ -1,234 +0,0 @@
package com.xmomen.module.pick.model;
import java.io.Serializable;
import java.math.BigDecimal;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.NotBlank;
public class CreateMember implements Serializable{
/**
* 会员编号
*/
private String memberCode;
/**
* 姓名
*/
@NotNull
@NotBlank
private String name;
/**
* 手机号
*/
@NotNull
@NotBlank
private String phoneNumber;
private String spareName;
private String spareName2;
/**
* 备用手机号1
*/
private String spareTel;
/**
* 备用手机号2
*/
private String spareTel2;
/**
* 家庭固话
*/
private String telNumber;
/**
* 办公室电话
*/
private String officeTel;
/**
* 收货地址
*/
@NotNull
@NotBlank
private String address;
/**
* 备用地址1
*/
private String spareAddress;
/**
* 备用地址2
*/
private String spareAddress2;
/**
* 1-潜在客户，2-普通客户，3-优质客户
*/
private Integer memberType;
/**
* 所属单位
*/
private Integer cdCompanyId;
/**
* 所属客服经理
*/
private Integer cdUserId;
private String newCouponNo;
private String newPassword;
private BigDecimal userPrice;
public String getMemberCode() {
return memberCode;
}
public void setMemberCode(String memberCode) {
this.memberCode = memberCode;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
public String getSpareTel() {
return spareTel;
}
public void setSpareTel(String spareTel) {
this.spareTel = spareTel;
}
public String getSpareTel2() {
return spareTel2;
}
public void setSpareTel2(String spareTel2) {
this.spareTel2 = spareTel2;
}
public String getTelNumber() {
return telNumber;
}
public void setTelNumber(String telNumber) {
this.telNumber = telNumber;
}
public String getOfficeTel() {
return officeTel;
}
public void setOfficeTel(String officeTel) {
this.officeTel = officeTel;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getSpareAddress() {
return spareAddress;
}
public void setSpareAddress(String spareAddress) {
this.spareAddress = spareAddress;
}
public String getSpareAddress2() {
return spareAddress2;
}
public void setSpareAddress2(String spareAddress2) {
this.spareAddress2 = spareAddress2;
}
public Integer getMemberType() {
return memberType;
}
public void setMemberType(Integer memberType) {
this.memberType = memberType;
}
public Integer getCdCompanyId() {
return cdCompanyId;
}
public void setCdCompanyId(Integer cdCompanyId) {
this.cdCompanyId = cdCompanyId;
}
public Integer getCdUserId() {
return cdUserId;
}
public void setCdUserId(Integer cdUserId) {
this.cdUserId = cdUserId;
}
public String getSpareName() {
return spareName;
}
public void setSpareName(String spareName) {
this.spareName = spareName;
}
public String getSpareName2() {
return spareName2;
}
public void setSpareName2(String spareName2) {
this.spareName2 = spareName2;
}
public String getNewCouponNo() {
return newCouponNo;
}
public void setNewCouponNo(String newCouponNo) {
this.newCouponNo = newCouponNo;
}
public String getNewPassword() {
return newPassword;
}
public void setNewPassword(String newPassword) {
this.newPassword = newPassword;
}
public BigDecimal getUserPrice() {
return userPrice;
}
public void setUserPrice(BigDecimal userPrice) {
this.userPrice = userPrice;
}
}

1048
src/main/java/com/xmomen/module/pick/model/TbRechargeLogExample.java
View File

File diff suppressed because it is too large Load Diff

119
src/main/java/com/xmomen/module/pick/service/impl/PickServiceImpl.java
Unescape View File

@ -23,92 +23,183 @@ import com.xmomen.module.system.entity.SysUserOrganization;
@Service
public class PickServiceImpl implements PickService {
// 注入 MybatisDao，用于执行数据库操作
@Autowired
private MybatisDao mybatisDao;
/**
* 处理提货业务逻辑，根据提货信息进行相应的验证和数据库操作
* @param pickVo 包含提货相关信息的对象
*/
@Override
@Transactional
@Transactional // 开启事务，确保该方法内的数据库操作要么全部成功，要么全部失败
public void pick(PickVo pickVo) {
// 创建一个 CdCoupon 对象，用于查询对应的优惠券信息
CdCoupon coupon = new CdCoupon();
// 设置优惠券对象的优惠券编号，从 pickVo 中获取
coupon.setCouponNumber(pickVo.getCouponNo());
// 通过 mybatisDao 根据设置好的条件查询单个优惠券信息
coupon = mybatisDao.selectOneByModel(coupon);
AssertExt.notNull(coupon,"卡号不存在！");
// 验证查询到的优惠券是否为空，如果为空则抛出异常，提示卡号不存在
AssertExt.notNull(coupon, "卡号不存在！");
// 获取提货支付类型，并转换为 int 类型
int pickPayType = pickVo.getPickPayType().intValue();
// 获取提货的总价格
BigDecimal pickPrice = pickVo.getPickPrice();
// 获取现金支付的价格，如果为空则默认为 0
BigDecimal casePrice = pickVo.getPickCasePrice() == null ? BigDecimal.ZERO : pickVo.getPickCasePrice();
// 计算刷卡支付的价格，即总价格减去现金支付价格
BigDecimal cradPrice = pickPrice.subtract(casePrice);
if(pickPayType == 1 || pickPayType == 2){//刷卡 || 现金+刷卡
// 如果支付类型为刷卡（1）或者现金 + 刷卡（2）
if (pickPayType == 1 || pickPayType == 2) {
// 获取优惠券的可用余额
BigDecimal usePrice = coupon.getUserPrice();
// 计算使用刷卡支付后优惠券的剩余余额
BigDecimal diffPrice = usePrice.subtract(cradPrice);
AssertExt.isTrue(diffPrice.doubleValue() >= 0.00,"余额不足");
// 验证剩余余额是否大于等于 0，如果小于 0 则抛出异常，提示余额不足
AssertExt.isTrue(diffPrice.doubleValue() >= 0.00, "余额不足");
// 更新优惠券的可用余额为剩余余额
coupon.setUserPrice(diffPrice);
// 通过 mybatisDao 更新数据库中的优惠券信息
mybatisDao.update(coupon);
}else if(pickPayType == 3){//现金
AssertExt.isTrue(casePrice.compareTo(pickPrice) != 0,"付款金额错误");
}
// 如果支付类型为现金（3）
else if (pickPayType == 3) {
// 验证现金支付价格是否不等于总价格，如果相等则抛出异常，提示付款金额错误
AssertExt.isTrue(casePrice.compareTo(pickPrice) != 0, "付款金额错误");
}
// 从当前会话中获取用户 ID
Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
// 创建一个 SysUserOrganization 对象，用于查询用户所属的组织信息
SysUserOrganization userOrganization = new SysUserOrganization();
// 设置用户组织对象的用户 ID
userOrganization.setUserId(userId);
// 通过 mybatisDao 根据设置好的条件查询单个用户组织信息
userOrganization = mybatisDao.selectOneByModel(userOrganization);
// 创建一个 TbPick 对象，用于记录提货信息
TbPick pick = new TbPick();
// 设置提货对象的优惠券编号
pick.setCouponNo(pickVo.getCouponNo());
// 设置提货对象的现金支付价格
pick.setPickCasePrice(casePrice);
// 设置提货对象的刷卡支付价格
pick.setPickCradPrice(cradPrice);
// 设置提货对象的提货日期，从 mybatisDao 获取系统日期
pick.setPickDate(mybatisDao.getSysdate());
// 设置提货对象的提货地点用户 ID
pick.setPickPlaceUser(userId);
// 设置提货对象的提货地点，即用户所属组织的 ID
pick.setPickPlace(userOrganization.getOrganizationId());
// 设置提货对象的提货总价格
pick.setPickTotalPrice(pickPrice);
// 设置提货对象的提货重量，从 pickVo 中获取
pick.setPickWeight(pickVo.getPickWeight());
// 通过 mybatisDao 将提货信息保存到数据库中
mybatisDao.save(pick);
}
/**
* 处理绑卡充值业务逻辑，包括验证优惠券、绑定会员、更新优惠券余额和记录充值日志
* @param createMember 包含新卡信息和充值信息的对象
*/
@Override
public void pickCard(CreateMember createMember) {
// 创建一个 CdCoupon 对象，用于查询对应的优惠券信息
CdCoupon coupon = new CdCoupon();
// 设置优惠券对象的优惠券编号，从 createMember 中获取
coupon.setCouponNumber(createMember.getNewCouponNo());
// 设置优惠券对象的优惠券密码，从 createMember 中获取
coupon.setCouponPassword(createMember.getNewPassword());
// 通过 mybatisDao 根据设置好的条件查询单个优惠券信息
coupon = mybatisDao.selectOneByModel(coupon);
AssertExt.notNull(coupon,"卡号不存在！");
// 验证查询到的优惠券是否为空，如果为空则抛出异常，提示卡号不存在
AssertExt.notNull(coupon, "卡号不存在！");
// 创建一个 CdMemberCouponRelation 对象，用于查询该优惠券是否已绑定会员
CdMemberCouponRelation cdMemberCouponRelation = new CdMemberCouponRelation();
// 设置会员优惠券关系对象的优惠券编号
cdMemberCouponRelation.setCouponNumber(coupon.getCouponNumber());
// 通过 mybatisDao 根据设置好的条件查询单个会员优惠券关系信息
cdMemberCouponRelation = mybatisDao.selectOneByModel(cdMemberCouponRelation);
AssertExt.isNull(cdMemberCouponRelation,"该卡已绑定客户，不能再绑定");
// 验证查询到的会员优惠券关系是否为空，如果不为空则抛出异常，提示该卡已绑定客户
AssertExt.isNull(cdMemberCouponRelation, "该卡已绑定客户，不能再绑定");
// 创建一个 CdMember 对象，用于保存新会员信息
CdMember member = new CdMember();
// 设置会员对象的会员类型，从 createMember 中获取
member.setMemberType(createMember.getMemberType());
// 设置会员对象的姓名，从 createMember 中获取
member.setName(createMember.getName());
// 设置会员对象的手机号码，从 createMember 中获取
member.setPhoneNumber(createMember.getPhoneNumber());
// 设置会员对象的备用姓名 1，从 createMember 中获取
member.setSpareName(createMember.getSpareName());
// 设置会员对象的备用姓名 2，从 createMember 中获取
member.setSpareName2(createMember.getSpareName2());
// 设置会员对象的备用电话 1，从 createMember 中获取
member.setSpareTel(createMember.getSpareTel());
// 设置会员对象的备用电话 2，从 createMember 中获取
member.setSpareTel2(createMember.getSpareTel2());
// 设置会员对象的电话号码，从 createMember 中获取
member.setTelNumber(createMember.getTelNumber());
// 设置会员对象的办公电话，从 createMember 中获取
member.setOfficeTel(createMember.getOfficeTel());
// 设置会员对象的地址，从 createMember 中获取
member.setAddress(createMember.getAddress());
// 设置会员对象的备用地址 1，从 createMember 中获取
member.setSpareAddress(createMember.getSpareAddress());
// 设置会员对象的备用地址 2，从 createMember 中获取
member.setSpareAddress2(createMember.getSpareAddress2());
// 设置会员对象所属公司的 ID，从 createMember 中获取
member.setCdCompanyId(createMember.getCdCompanyId());
// 设置会员对象所属用户的 ID，从 createMember 中获取
member.setCdUserId(createMember.getCdUserId());
// 通过 mybatisDao 插入新会员信息到数据库，并返回插入后的会员对象
member = mybatisDao.insertByModel(member);
// 创建一个新的 CdMemberCouponRelation 对象，用于记录新的会员优惠券绑定关系
CdMemberCouponRelation cdMemberCouponRelation2 = new CdMemberCouponRelation();
// 设置新的会员优惠券关系对象的会员 ID
cdMemberCouponRelation2.setCdMemberId(member.getId());
// 设置新的会员优惠券关系对象的优惠券编号
cdMemberCouponRelation2.setCouponNumber(coupon.getCouponNumber());
// 通过 mybatisDao 将新的会员优惠券绑定关系插入到数据库中
mybatisDao.insert(cdMemberCouponRelation2);
//记录充值记录
BigDecimal userPrice = coupon.getUserPrice()==null?BigDecimal.ZERO:coupon.getUserPrice();
// 记录充值记录
// 获取优惠券的可用余额，如果为空则默认为 0
BigDecimal userPrice = coupon.getUserPrice() == null ? BigDecimal.ZERO : coupon.getUserPrice();
// 更新优惠券的可用余额，加上充值金额
coupon.setUserPrice(userPrice.add(createMember.getUserPrice()));
// 通过 mybatisDao 更新数据库中的优惠券信息
mybatisDao.update(coupon);
// 从当前会话中获取用户 ID
Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
// 创建一个 SysUserOrganization 对象，用于查询用户所属的组织信息
SysUserOrganization userOrganization = new SysUserOrganization();
// 设置用户组织对象的用户 ID
userOrganization.setUserId(userId);
// 通过 mybatisDao 根据设置好的条件查询单个用户组织信息
userOrganization = mybatisDao.selectOneByModel(userOrganization);
// 创建一个 TbRechargeLog 对象，用于记录充值日志
TbRechargeLog rechargeLog = new TbRechargeLog();
// 设置充值日志对象的优惠券编号
rechargeLog.setCouponNo(coupon.getCouponNumber());
// 设置充值日志对象的充值日期，从 mybatisDao 获取系统日期
rechargeLog.setRechargeDate(mybatisDao.getSysdate());
// 设置充值日志对象的充值地点，即用户所属组织的 ID
rechargeLog.setRechargePlace(userOrganization.getOrganizationId());
// 设置充值日志对象的充值金额，从 createMember 中获取
rechargeLog.setRechargePrice(createMember.getUserPrice());
// 设置充值日志对象的充值用户 ID
rechargeLog.setRechargeUser(userId);
// 通过 mybatisDao 将充值日志信息保存到数据库中
mybatisDao.save(rechargeLog);
}

Write Preview
Loading…
Cancel
Save