Skip to content

O
oms-ci-test
提交 6ea140cb 作者: 张小凤
操作

Coupon(add)

上级 dcabd811
正在显示 包含 9594 行增加 和 1 行删除
pom.xml
......@@ -18,10 +18,46 @@
</properties>
<dependencies>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-base</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-web</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>cn.afterturn</groupId>
<artifactId>easypoi-annotation</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.15</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel-core</artifactId>
<version>3.1.3</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel-core</artifactId>
<version>3.1.3</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
......
src/main/java/com/mmc/oms/common/AuthHandler.java 0 → 100644
package com.mmc.oms.common;
import com.alibaba.fastjson.JSONArray;
import com.mmc.oms.jwt.JwtConstant;
import com.mmc.oms.jwt.JwtUtil;
import com.mmc.oms.model.dto.BaseAccountDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* @Author small
* @Date 2023/5/24 15:59
* @Version 1.0
*/
@Component
public class AuthHandler {
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 获取当前用户
*
* @param request
* @return
*/
// public CurrentUserDTO getCurrentUser(HttpServletRequest request) {
// // 登录未做好-统一通过此方法获取当前用户信息
// Integer id = Integer.parseInt(request.getHeader(JwtConstant.USERIDKEY).toString());
// Integer roleId = Integer.parseInt(request.getHeader(JwtConstant.ROLEIDKEY).toString());
// return CurrentUserDTO.builder().id(id).roleId(roleId).build();
// }
/**
* 获取当前登录账号信息
*/
public BaseAccountDTO getCurrentAccount(String token) {
// 获取登录的基本信息
String json = stringRedisTemplate.opsForValue().get(token);
if (StringUtils.isEmpty(json)) {
throw new BizException(ResultEnum.LOGIN_ACCOUNT_STATUS_ERROR);
}
BaseAccountDTO account = JsonUtil.parseJsonToObj(json, BaseAccountDTO.class);
// 如果是PC管理端-获取部门缓存信息
if (JwtConstant.SXTB_ACCOUNT_TOKEN.equals(account.getTokenPort())) {
account.getCompanyInfo().setCompanys(this.getCompanys(account.getCompanyInfo().getId()));
}
return account;
}
public String addLoginCache(Integer userId, Integer roleId, String tokenType, BaseAccountDTO loginInfo) {
Map<String, Object> map = new HashMap<String, Object>();
map.put(JwtConstant.USERIDKEY, userId);
map.put(JwtConstant.ROLEIDKEY, roleId);
map.put(JwtConstant.TOKEN_TYPE, tokenType);
String token = JwtUtil.createJwt(map);
loginInfo.setTokenPort(tokenType);
// 缓存登录token-jwt
stringRedisTemplate.opsForValue().set(
RedisConstant.createLoginTokenKey(tokenType, roleId.toString(), userId.toString()), token,
JwtConstant.EXPIRATION, TimeUnit.MILLISECONDS);
// 平台PC管理端登录保存-单位的id及无限下级id集合
if (JwtConstant.SXTB_ACCOUNT_TOKEN.equals(tokenType)) {
if (loginInfo.getCompanyInfo() != null && !CollectionUtils.isEmpty(loginInfo.getCompanyInfo().getCompanys())) {
List<Integer> companys = loginInfo.getCompanyInfo().getCompanys();
this.refreshCompanys(companys, loginInfo.getCompanyInfo().getId());
// 置为null--省内存
loginInfo.getCompanyInfo().setCompanys(null);
}
}
// 缓存登录对象
stringRedisTemplate.opsForValue().set(token, JsonUtil.parseObjToJson(loginInfo), JwtConstant.EXPIRATION,
TimeUnit.MILLISECONDS);
return token;
}
/**
* 更新单位缓存
*
* @param companys
* @param companyId
*/
public void refreshCompanys(List<Integer> companys, Integer companyId) {
String key = RedisConstant.getCompanyChildKey(companyId);
stringRedisTemplate.opsForValue().set(
key, JsonUtil.parseObjToJson(companys),
JwtConstant.EXPIRATION, TimeUnit.MILLISECONDS);
}
public List<Integer> getCompanys(Integer companyId) {
String key = RedisConstant.getCompanyChildKey(companyId);
if (stringRedisTemplate.hasKey(key)) {
String json = stringRedisTemplate.opsForValue().get(key);
if(!StringUtils.isEmpty(json)) {
List<Integer> list = JSONArray.parseArray(json, Integer.class);
return list;
}
}
return new ArrayList<Integer>();
}
public void updateLoginCache(String token, BaseAccountDTO loginInfo) {
stringRedisTemplate.opsForValue().set(token, JsonUtil.parseObjToJson(loginInfo), JwtConstant.EXPIRATION,
TimeUnit.MILLISECONDS);
}
/**
* 检验缓存token是否存在
*
* @param token
* @return
*/
public boolean hasToken(String token) {
return stringRedisTemplate.hasKey(token);
}
/**
* 检验token是否进了失效名单 && 检验token是否为最新token
*
* @param token
* @return
*/
public boolean isDisableToken(String token) {
List<String> disableTokens = stringRedisTemplate.opsForList().range(RedisConstant.DISABLE_TOKEN_LIST, 0, -1);// 需要强制失效的token
return (!CollectionUtils.isEmpty(disableTokens) && disableTokens.contains(token));
}
/**
* 检测是否为最新的token
*
* @param userId
* @param roleId
* @param tokenType
*/
public boolean isLatestToken(String userId, String roleId, String tokenType, String token) {
String key = RedisConstant.createLoginTokenKey(tokenType, roleId, userId);
return (token.equals(stringRedisTemplate.opsForValue().get(key)));
}
public String getUserToken(Integer userAccountId, Integer roleId, String tokenType) {
String token = stringRedisTemplate.opsForValue()
.get(RedisConstant.createLoginTokenKey(tokenType, roleId.toString(), userAccountId.toString()));// 查询他的token
return token;
}
public void disableOneToken(Integer userAccountId, Integer roleId, String tokenType) {
String token = this.getUserToken(userAccountId, roleId, tokenType);// 查询他的token
if (!StringUtils.isEmpty(token)) {
stringRedisTemplate.opsForList().leftPush(RedisConstant.DISABLE_TOKEN_LIST, token);// 加入token失效列表
}
String cacheLoginKey = RedisConstant.createLoginCacheKey(tokenType, userAccountId);
stringRedisTemplate.delete(cacheLoginKey);// 删除登录信息
}
public void disableListToken(List<Integer> userAccountIds, Integer roleId, String tokenType) {
Set<String> tokenKeyList = stringRedisTemplate
.keys(RedisConstant.tokenPreFix(tokenType, roleId.toString()) + "*");// 模糊查询所有key
if (!CollectionUtils.isEmpty(tokenKeyList)) {
List<String> tokenList = stringRedisTemplate.opsForValue().multiGet(tokenKeyList);
stringRedisTemplate.opsForList().leftPushAll(RedisConstant.DISABLE_TOKEN_LIST, tokenList);
}
userAccountIds.forEach(id -> {
String cacheLoginKey = RedisConstant.createLoginCacheKey(tokenType, id);
stringRedisTemplate.delete(cacheLoginKey);
});
}
}
src/main/java/com/mmc/oms/common/BaseErrorInfoInterface.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 13:36
* @Version 1.0
*/
public interface BaseErrorInfoInterface {
/**
* 错误码
*
* @return
*/
String getResultCode();
/**
* 错误描述
*
* @return
*/
String getResultMsg();
}
src/main/java/com/mmc/oms/common/BizException.java 0 → 100644
package com.mmc.oms.common;
import static com.mmc.oms.common.ResultEnum.CUSTOM_ERROR;
/**
* @Author small
* @Date 2023/5/24 16:00
* @Version 1.0
*/
public class BizException extends RuntimeException {
private static final long serialVersionUID = 1L;
/**
* 错误码
*/
protected String errorCode;
/**
* 错误信息
*/
protected String errorMsg;
public BizException() {
super();
}
public BizException(BaseErrorInfoInterface errorInfoInterface) {
super(errorInfoInterface.getResultCode());
this.errorCode = errorInfoInterface.getResultCode();
this.errorMsg = errorInfoInterface.getResultMsg();
}
public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
super(errorInfoInterface.getResultCode(), cause);
this.errorCode = errorInfoInterface.getResultCode();
this.errorMsg = errorInfoInterface.getResultMsg();
}
public BizException(ResultEnum enums) {
super(enums.getResultCode());
this.errorCode = enums.getResultCode();
this.errorMsg = enums.getResultMsg();
}
public BizException(String errorMsg) {
super(errorMsg);
this.errorCode = CUSTOM_ERROR.resultCode;
this.errorMsg = errorMsg;
}
public BizException(String errorCode, String errorMsg) {
super(errorCode);
this.errorCode = errorCode;
this.errorMsg = errorMsg;
}
public BizException(String errorCode, String errorMsg, Throwable cause) {
super(errorCode, cause);
this.errorCode = errorCode;
this.errorMsg = errorMsg;
}
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorMsg() {
return errorMsg;
}
public void setErrorMsg(String errorMsg) {
this.errorMsg = errorMsg;
}
@Override
public String getMessage() {
return errorMsg;
}
@Override
public Throwable fillInStackTrace() {
return this;
}
}
src/main/java/com/mmc/oms/common/CodeUtil.java 0 → 100644
package com.mmc.oms.common;
import java.util.Random;
/**
* @Author small
* @Date 2023/5/24 16:02
* @Version 1.0
*/
public class CodeUtil {
private static Random random = new Random();
// 数据生成有位数字或字母的随机数
public static String randomCode(int num) {
// 0-61 9 9+26=35 35+26 =61 65-90 97-122
StringBuffer sb = new StringBuffer();
for (int i = 0; i < num; i++) {
int y = random.nextInt(62);
if (y <= 9) {
// 数值
sb.append(y);
} else {
if (y <= 35) {
// 大写字母
y += 55;
} else {
// 小写字母
y += 61;
}
sb.append((char) y);
}
}
return sb.toString();
}
/**
* 生成随机数字
*
* @param length[生成随机数的长度]
* @return
*/
public static String getRandomNum(int length) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < length; i++) {
sb.append(String.valueOf(random.nextInt(10)));
}
return sb.toString();
}
/**
* 生成用户uid
*
* @return
*/
public static String createUserUID() {
return "UID" + CodeUtil.getRandomNum(7);
}
/**
* 生成-现金流水账目no
*/
public static String createPayCashNO() {
StringBuffer sb = new StringBuffer();
sb.append("T");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成-信用流水账目no
*/
public static String createPayCreditNo() {
StringBuffer sb = new StringBuffer();
sb.append("T");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成-飞手工资流水账目no
*/
public static String createPayWagNo() {
StringBuffer sb = new StringBuffer();
sb.append("T");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成订单no
*/
public static String createOrderTaskNO() {
StringBuffer sb = new StringBuffer();
sb.append("D");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成-信用返利账目no
*/
public static String createPayRebateNo() {
StringBuffer sb = new StringBuffer();
sb.append("T");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成行业no
*/
public static String createIndustryNO() {
StringBuffer sb = new StringBuffer();
sb.append("HY");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成服务no
*/
public static String createInspectionNO() {
StringBuffer sb = new StringBuffer();
sb.append("FW");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成服务no
*/
public static String createRoleNo() {
StringBuffer sb = new StringBuffer();
sb.append("JS");
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成商品编号
*
* @return
*/
public static String createWareID() {
return "ID" + CodeUtil.getRandomNum(10);
}
/**
* 生成云仓订单编号
*/
public static String createRepoOrderNo() {
StringBuffer sb = new StringBuffer();
sb.append("R");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 云仓现金流水
*/
public static String createRepoCashNo() {
StringBuffer sb = new StringBuffer();
sb.append("J");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 生成商品编号
*
* @return
*/
public static String createDeviceCode() {
return "DC" + CodeUtil.getRandomNum(6);
}
/**
* 云仓现金流水
*/
public static String createOrderRefund() {
StringBuffer sb = new StringBuffer();
sb.append("RD");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 返祖订单号
*/
public static String createShareOrderNo() {
StringBuffer sb = new StringBuffer();
sb.append("GX");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmm"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 型号编号
*/
public static String createDeviceModelNo() {
return "DM" + CodeUtil.getRandomNum(8);
}
/**
* 仓库编号
*/
public static String createRepoNo() {
return "RN" + CodeUtil.getRandomNum(8);
}
public static String uavOrderCode(Long id) {
StringBuffer sb = new StringBuffer();
sb.append("UD");
sb.append(TDateUtil.getCurrentDateByType("yyyyMMddHHmmss"));
sb.append(CodeUtil.getRandomNum(4));
return sb.toString();
}
/**
* 活动编号
*/
public static String generateActivityNo() {
return "AC" + CodeUtil.getRandomNum(5);
}
}
src/main/java/com/mmc/oms/common/CouponConstants.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 14:03
* @Version 1.0
*/
public class CouponConstants {
/**
* --------优惠券常量------------
*/
/** 优惠券类型—打折券 */
public static final Integer COUPON_TYPE_DISCOUNT = 1;
/** 优惠券类型—减免券 */
public static final Integer COUPON_TYPE_REDUCED = 2;
/** 优惠券类型—无门槛 */
public static final Integer COUPON_TYPE_NO_THRESHOLD = 3;
/** 优惠券使用类型—vip */
public static final Integer COUPON_USR_TYPE_VIP = 1;
/** 优惠券使用类型—品牌券 */
public static final Integer COUPON_USR_TYPE_BRAND = 2;
/** 优惠券有效期时间方式-固定时间 */
public static final Integer COUPON_USE_TIME_FIXED = 0;
/** 优惠券有效期时间方式-领取当日起 */
public static final Integer COUPON_USE_TIME_THE_DAY = 1;
/** 优惠券有效期时间方式-领取次日起 */
public static final Integer COUPON_USE_TIME_NEXT_DAY = 2;
/** 优惠券发放方式—手动领取 */
public static final Integer COUPON_ISSUE_TYPE_RECEIVE = 1;
/** 优惠券发放方式—系统发放 */
public static final Integer COUPON_ISSUE_TYPE_INITIATIVE =2;
/** 优惠券发放方式—批量导入用户 */
public static final Integer COUPON_ISSUE_TYPE_IMPORT = 3;
/** 优惠券使用类型—活动裂变券 */
public static final Integer COUPON_USR_TYPE_ACTIVITY = 4;
/** 用户标签-新人 */
public static final Integer USER_LABEL_NEW_PEOPLE = 1;
/** 用户标签-实名认证 */
public static final Integer USER_LABEL_REAL_NAME_AUTHENTICATION = 2;
/** 用户标签-企业认证 */
public static final Integer USER_LABEL_ENTERPRISE_CERTIFICATION = 3;
/**
* --------用户优惠券常量----------------
*/
/** 用户优惠券获取方式—用户领取 */
public static final String STORE_COUPON_USER_TYPE_GET = "receive";
/** 用户优惠券获取方式—后台发放 */
public static final String STORE_COUPON_USER_TYPE_SEND = "send";
/** 用户优惠券获取方式—赠送 */
public static final String STORE_COUPON_USER_TYPE_PRESENTED = "presented";
/** 用户优惠券获取方式—获赠 */
public static final String STORE_COUPON_USER_TYPE_ACQUIRE = "acquire";
/** 用户优惠券获取方式—兑换 */
public static final String STORE_COUPON_USER_TYPE_EXCHANGE = "exchange";
/** 用户优惠券获取方式—活动领取 */
public static final String STORE_COUPON_USER_TYPE_ACTIVITY = "activity";
/** 用户优惠券状态—未使用 */
public static final Integer STORE_COUPON_USER_STATUS_USABLE = 0;
/** 用户优惠券状态—已使用 */
public static final Integer STORE_COUPON_USER_STATUS_USED = 1;
/** 用户优惠券状态—已失效 */
public static final Integer STORE_COUPON_USER_STATUS_LAPSED = 2;
/** 用户优惠券状态—已转赠 */
public static final Integer STORE_COUPON_USER_STATUS_PRESENTED = 3;
/** 用户优惠券状态—使用中 */
public static final Integer STORE_COUPON_USER_STATUS_IN_USE = 4;
}
src/main/java/com/mmc/oms/common/CouponType.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 16:11
* @Version 1.0
*/
public interface CouponType {
//打折券
public static final Integer DISCOUNT_COUPONS=1;
//减免卷
public static final Integer REDUCTION_ROLLS=2;
//无门槛
public static final Integer NO_THRESHOLD=3;
}
src/main/java/com/mmc/oms/common/CouponUserExcel.java 0 → 100644
package com.mmc.oms.common;
import cn.afterturn.easypoi.excel.annotation.Excel;
import cn.afterturn.easypoi.excel.annotation.ExcelTarget;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 15:23
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@ExcelTarget("couponUserExcel")
public class CouponUserExcel implements Serializable {
private static final long serialVersionUID=1L;
@Excel(name = "优惠券id", orderNum = "1", width = 25)
private Integer couponId;
@Excel(name = "领取人id", orderNum = "2", width = 25)
private Integer uid;
@Excel(name = "领取人手机号码", orderNum = "3", width = 25)
private String userPhone;
@Excel(name = "优惠券名称", orderNum = "4", width = 25)
private String couponName;
@Excel(name = "获取方式", orderNum = "5", width = 25)
private String gainType;
@Excel(name = "状态", orderNum = "6", width = 25)
private String status;
@Excel(name = "领取时间", orderNum = "7", width = 25, databaseFormat = "yyyyMMddHHmmss", format = "yyyy-MM-dd hh:mm:ss", isImportField = "true_st", timezone = "Asia/Shanghai")
private Date createTime;
@Excel(name = "使用时间", orderNum = "8", width = 25, databaseFormat = "yyyyMMddHHmmss", format = "yyyy-MM-dd hh:mm:ss", isImportField = "true_st", timezone = "Asia/Shanghai")
private Date useTime;
@Excel(name = "订单编码", orderNum = "9", width = 25)
private String orderNo;
}
src/main/java/com/mmc/oms/common/Create.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 15:26
* @Version 1.0
*/
public interface Create {
}
src/main/java/com/mmc/oms/common/EasyExcelListener.java 0 → 100644
package com.mmc.oms.common;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.read.listener.ReadListener;
import java.util.ArrayList;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:37
* @Version 1.0
*/
public final class EasyExcelListener<T> implements ReadListener<T> {
/**
* 缓存的数据
*/
private List<T> cachedDataList = new ArrayList<>();
@Override
@SuppressWarnings("unchecked")
public void invoke(Object object, AnalysisContext analysisContext) {
T map = (T) object;
cachedDataList.add(map);
}
@Override
public void doAfterAllAnalysed(AnalysisContext analysisContext) {
}
public List<T> getCachedDataList() {
return cachedDataList;
}
public void setCachedDataList(List<T> cachedDataList){
this.cachedDataList = cachedDataList;
}
}
src/main/java/com/mmc/oms/common/FlyerAccountType.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 15:07
* @Version 1.0
*/
public enum FlyerAccountType {
YK(0, "游客"), PT(1, "普通用户"), GR(2, "个人飞手"), JG(3, "飞手机构");
FlyerAccountType(Integer code, String status) {
this.code = code;
this.status = status;
}
private Integer code;
private String status;
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
}
src/main/java/com/mmc/oms/common/Freeze.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 14:02
* @Version 1.0
*/
public interface Freeze {
}
src/main/java/com/mmc/oms/common/Insert.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 14:00
* @Version 1.0
*/
public interface Insert {
}
src/main/java/com/mmc/oms/common/JsonUtil.java 0 → 100644
package com.mmc.oms.common;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import java.io.*;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 16:01
* @Version 1.0
*/
public class JsonUtil {
public static void main(String[] args) {
String array = "[1,24,23]";
List<Integer> list = JSONArray.parseArray(array, Integer.class);
System.out.println(list.get(2));
}
/**
* 把Java对象转换成json字符串
*
* @param object 待转化为JSON字符串的Java对象
* @return json 串 or null
*/
public static String parseObjToJson(Object object) {
String string = null;
try {
string = JSONObject.toJSONString(object);
} catch (Exception e) {
// LOGGER.error(e.getMessage());
}
return string;
}
/**
* 将Json字符串信息转换成对应的Java对象
*
* @param json json字符串对象
* @param c 对应的类型
*/
public static <T> T parseJsonToObj(String json, Class<T> c) {
try {
JSONObject jsonObject = JSON.parseObject(json);
return JSON.toJavaObject(jsonObject, c);
} catch (Exception e) {
// LOGGER.error(e.getMessage());
}
return null;
}
/**
* 读取json文件
*
* @param fileName
* @return
*/
public static String readJsonFile(String fileName) {
String jsonStr = "";
try {
File jsonFile = new File(fileName);
FileReader fileReader = new FileReader(jsonFile);
Reader reader = new InputStreamReader(new FileInputStream(jsonFile), "utf-8");
int ch = 0;
StringBuffer sb = new StringBuffer();
while ((ch = reader.read()) != -1) {
sb.append((char) ch);
}
fileReader.close();
reader.close();
jsonStr = sb.toString();
return jsonStr;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
/**
* 将JSON数据格式化并保存到文件中
*
* @param jsonData 需要输出的json数
* @param filePath 输出的文件地址
* @return
*/
public static boolean createJsonFile(Object jsonData, String filePath) {
String content = JSON.toJSONString(jsonData, SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue,
SerializerFeature.WriteDateUseDateFormat);
// 标记文件生成是否成功
boolean flag = true;
// 生成json格式文件
try {
// 保证创建一个新文件
File file = new File(filePath);
if (!file.getParentFile().exists()) { // 如果父目录不存在，创建父目录
file.getParentFile().mkdirs();
}
if (file.exists()) { // 如果已存在,删除旧文件
file.delete();
}
file.createNewFile();
// 将格式化后的字符串写入文件
Writer write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
write.write(content);
write.flush();
write.close();
} catch (Exception e) {
flag = false;
e.printStackTrace();
}
return flag;
}
}
src/main/java/com/mmc/oms/common/MsgData.java 0 → 100644
package com.mmc.oms.common;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 16:14
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class MsgData implements Serializable {
private static final long serialVersionUID = 1479503488297727536L;
private String value;
private String color = "#173177";// 字体颜色
}
src/main/java/com/mmc/oms/common/Others.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 14:31
* @Version 1.0
*/
public interface Others {
}
src/main/java/com/mmc/oms/common/Page.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 14:01
* @Version 1.0
*/
public interface Page {
}
src/main/java/com/mmc/oms/common/PageResult.java 0 → 100644
package com.mmc.oms.common;
import com.mmc.oms.model.qo.BaseInfoQO;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:19
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PageResult<T> implements Serializable {
private static final long serialVersionUID = -2848996493573325801L;
private int pageNo;// 分页起始页
private int pageSize;// 每页记录数
private T list;// 返回的记录集合
private long totalCount;// 总记录条数
private long totalPage;// 总页数
public static PageResult buildPage(int pageNo, int pageSize, int totalCount) {
PageResult page = new PageResult();
page.pageNo = pageNo;
page.pageSize = pageSize;
page.totalCount = totalCount;
page.totalPage = (totalCount % pageSize == 0) ? (totalCount / pageSize) : (totalCount / pageSize + 1);
return page;
}
public static <T> PageResult buildPage(int pageNo, int pageSize, int totalCount, T list) {
PageResult page = PageResult.buildPage(pageNo, pageSize, totalCount);
page.setList(list);
return page;
}
public static PageResult buildPage(BaseInfoQO qo, int totalCount) {
PageResult page = new PageResult();
page.pageNo = qo.getPageNo();
Integer pageSize = qo.getPageSize();
page.pageSize = pageSize;
page.totalCount = totalCount;
page.totalPage = (totalCount % pageSize == 0) ? (totalCount / pageSize) : (totalCount / pageSize + 1);
return page;
}
}
src/main/java/com/mmc/oms/common/Query.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 14:08
* @Version 1.0
*/
public interface Query {
}
src/main/java/com/mmc/oms/common/RedisConstant.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 16:03
* @Version 1.0
*/
public class RedisConstant {
/**
* 验证码-key
*/
public final static String VERIFYCODEKEY = "verifyCode";
/**
* 电话号码-key
*/
public final static String PHONENUMKEY = "phoneNum";
/**
* 当天用户量统计-key
*/
public final static String ACTIVE_USER_TOTAL_COUNT_TODAY = "active_user_total_count_today";
/**
* 后台-当天用户量统计-key
*/
public final static String ADMIN_ACTIVE_COUNT_TODAY = "admin_active_count_today";
/**
* 云享飞-当天用户量统计-key
*/
public final static String YXF_ACTIVE_COUNT_TODAY = "yxf_active_count_today";
/**
* 云飞手-当天用户量统计-key
*/
public final static String YFS_ACTIVE_COUNT_TODAY = "yfs_active_count_today";
/**
* 云仓-当天用户量统计-key
*/
public final static String YC_ACTIVE_COUNT_TODAY = "yc_active_count_today";
/**
* 登录信息token前缀
*/
public final static String LOGING_TOKEN_BEFORE = "CLOUD-SHARED-FLIGHT-USERID@";
/**
* token黑名单-key
*
* @param userId
* @return
*/
/**
* 实名认证 redis 的键
*/
public final static String REALNAMEREDISKEY = "realName";
/**
* token失效
*/
public final static String DISABLE_TOKEN = "DISABLE-TOKEN";
/**
* 分片上传的key
*
* @param userId
* @return
*/
public final static String PART_UPLOAD = "UPLOAD_PART_";
/**
* 飞手端-假数据-分页信息-可以
*/
public final static String FLYER_DUMMY_DATA_PAGE = "FLYER_DUMMY_DATA_PAGE";
/**
* token失效列表的key
*/
public final static String DISABLE_TOKEN_LIST = "DISABLE_TOKEN_LIST";
/**
* 无人机城的订单状态
*/
public final static String UAV_MALL_ORDER_STATUS = "UAV_MALL_ORDER_STATUS";
/**
* 无人机城的快递公司编码
*/
public final static String UAV_MALL_EXP_COM = "UAV_MALL_EXP_COM";
/**
* 无人机城的快递状态码
*/
public final static String UAV_MALL_EXP_STATUS = "UAV_MALL_EXP_STATUS";
/**
* 微信access_token
*
* @param userId
* @return
*/
public final static String WX_ACCESS_TOKEN_BEFORE = "WX_ACCESS_TOKEN_";
public final static String REPO_SEND_PAY_MESSAGE = "REPO_ORDER_REMIND_PAY_";
public final static String FLYER_PUBLIC_DEFAULT_NAME = "FLYER_PUBLIC_DEFAULT_NAME";
public final static String EVALUATION = "EVALUATION";
public final static String FLYER_DUMMY_DATA="FLYER_DUMMY_DATA_KEY";
public final static String UAV_DUMMY_DATA="UAV_DUMMY_DATA_KEY";
/**
* tagInfoAllot表的缓存key
*/
public final static String TAGINFOALLOT_QUESTALL = "csf-service-system:tagInfoAllot:questAll";
public static String getDisableTokenKey(String accountId, String roleId, String tokenType) {
StringBuffer key = new StringBuffer();
key.append(RedisConstant.DISABLE_TOKEN);
key.append("_ROLE_");
key.append(roleId);
key.append("_");
key.append(accountId);
return key.toString();
}
/**
* 生成唯一的分片上传key
*
* @param uploadId
* @return
*/
public static String createPartUploadKey(String uploadId) {
StringBuffer key = new StringBuffer();
key.append(uploadId);
return key.toString();
}
/**
* 生成微信api的access_token的key
*/
public static String createWxToken(String wxAppid) {
StringBuffer key = new StringBuffer();
key.append(RedisConstant.WX_ACCESS_TOKEN_BEFORE);
key.append(wxAppid);
return key.toString();
}
/**
* 表单重复提交key
*/
public static String createRepeatKey(String token, String url, String params) {
StringBuffer key = new StringBuffer();
key.append(token);
key.append(url);
key.append(params);
return key.toString();
}
public static String createRepeatKey(String token, String url) {
return RedisConstant.createRepeatKey(token, url, "");
}
/**
* 登录缓存信息
*/
public static String createLoginCacheKey(String tokenType, Integer id) {
StringBuffer key = new StringBuffer();
key.append(tokenType);
key.append("_");
key.append(id);
return key.toString();
}
/**
* 每位账号的的token的key的前缀
*/
public static String tokenPreFix(String tokenType, String roleId) {
StringBuffer key = new StringBuffer();
key.append(tokenType);
key.append("_ROLE_");
key.append(roleId);
key.append("_");
return key.toString();
}
/**
* 每位账号的token保存的key
*/
public static String createLoginTokenKey(String tokenType, String roleId, String accountId) {
StringBuffer key = new StringBuffer();
key.append(RedisConstant.tokenPreFix(tokenType, roleId));
key.append(accountId);
return key.toString();
}
public static String createRepoOrderOver(Integer orderInfoId) {
StringBuffer key = new StringBuffer();
key.append(RedisConstant.REPO_SEND_PAY_MESSAGE);
key.append(orderInfoId);
return key.toString();
}
public static String getLockKey(String userId, String tokenType, String path) {
StringBuffer sb = new StringBuffer();
sb.append(userId);
sb.append("_");
sb.append(tokenType);
sb.append("_");
sb.append(path);
return sb.toString();
}
public static String createInspection(Integer id) {
StringBuffer key = new StringBuffer();
key.append(RedisConstant.EVALUATION);
key.append(id);
return key.toString();
}
public static String accessTokenKey(String clientId, Integer roleId, String grantType) {
StringBuilder key = new StringBuilder();
key.append("OAUTH_");
key.append(clientId);
key.append("_");
key.append(roleId);
key.append("_");
key.append(grantType);
return key.toString();
}
public static String getCompanyChildKey(Integer companyId){
StringBuilder key = new StringBuilder();
key.append("company_cache:");
key.append(companyId);
return key.toString();
}
public static String getXEAccessTokenKey(){
StringBuilder key = new StringBuilder();
key.append("XE_ACCESS_TOKEN");
return key.toString();
}
}
src/main/java/com/mmc/oms/common/ResultBody.java 0 → 100644
package com.mmc.oms.common;
import com.alibaba.fastjson.JSONObject;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 13:36
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.result.ResultBody", description = "请求响应体")
public class ResultBody<T> implements Serializable {
private static final long serialVersionUID = 6341937455634693363L;
/**
* 响应代码
*/
@ApiModelProperty(value = "响应代码")
private String code;
/**
* 响应消息
*/
@ApiModelProperty(value = "响应消息")
private String message;
/**
* 响应结果
*/
@ApiModelProperty(value = "响应结果")
private T result;
public ResultBody(BaseErrorInfoInterface errorInfo) {
this.code = errorInfo.getResultCode();
this.message = errorInfo.getResultMsg();
}
/**
* 成功
*
* @return
*/
public static ResultBody success() {
return success(null);
}
/**
* 成功
*
* @param data
* @return
*/
public static <T> ResultBody success(T data) {
ResultBody rb = new ResultBody();
rb.setCode(ResultEnum.SUCCESS.getResultCode());
rb.setMessage(ResultEnum.SUCCESS.getResultMsg());
rb.setResult(data);
return rb;
}
/**
* 成功
*
* **/
public static ResultBody success1(ResultEnum enums){
ResultBody rb = new ResultBody();
rb.setCode("200");
rb.setMessage(enums.getResultMsg());
rb.setResult(null);
return rb;
}
public void buildSuccess() {
this.setCode(ResultEnum.SUCCESS.getResultCode());
this.setMessage(ResultEnum.SUCCESS.getResultMsg());
}
/**
* 失败
*/
public static ResultBody error(BaseErrorInfoInterface errorInfo) {
ResultBody rb = new ResultBody();
rb.setCode(errorInfo.getResultCode());
rb.setMessage(errorInfo.getResultMsg());
rb.setResult(null);
return rb;
}
/**
* 失败
*/
public static ResultBody error(String code, String message) {
ResultBody rb = new ResultBody();
rb.setCode(code);
rb.setMessage(message);
rb.setResult(null);
return rb;
}
/**
* 失败
*/
public static ResultBody error(ResultEnum enums) {
ResultBody rb = new ResultBody();
rb.setCode(enums.getResultCode());
rb.setMessage(enums.getResultMsg());
rb.setResult(null);
return rb;
}
/**
* 失败
*/
public static ResultBody error(String message) {
ResultBody rb = new ResultBody();
rb.setCode("-1");
rb.setMessage(message);
rb.setResult(null);
return rb;
}
/**
* 失败
*/
public static ResultBody error(ResultEnum enums, Object data) {
ResultBody rb = new ResultBody();
rb.setCode(enums.getResultCode());
rb.setMessage(enums.getResultMsg());
rb.setResult(data);
return rb;
}
public static boolean isSuccess(ResultBody res) {
return res.getCode().equals(ResultEnum.SUCCESS.getResultCode());
}
@Override
public String toString() {
return JSONObject.toJSONString(this);
}
}
src/main/java/com/mmc/oms/common/ResultEnum.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 13:37
* @Version 1.0
*/
public enum ResultEnum implements BaseErrorInfoInterface {
// 数据操作错误定义
SUCCESS("200", "success"), BODY_NOT_MATCH("400", "请求的数据格式不符!"), SIGNATURE_NOT_MATCH("401", "请求的数字签名不匹配!"),
NOT_FOUND("404", "未找到该资源!"), INTERNAL_SERVER_ERROR("500", "服务器内部错误!"), SERVER_BUSY("503", "服务器正忙，请稍后再试!"),
FILE_UPLOAD_ERROR("600", "文件上传有误"), FILE_UPLOAD_NULL_ERROR("601", "上传的文件不能为空"),
TOKEN_EXPIRED_ERROR("602", "登录信息已过期，请重新登录"), TOKEN_INVALID_ERROR("603", "无效的登录信息"),
VERIFY_CODE_ERROR("604", "验证码错误，请重新输入"), TOKEN_REDIS_ERROR("605", "登录失效"),
AUTH_ACCOUNT_ERROR("606", "当前账号未授权，请先授权"), TOEKN_REPEAT_ERROR("607", "该账号已在其他设备登录，请重新登录"),
TOKEN_NOT_VALID_ERROR("608", "access_token已失效或access_token不是最新的"),
SCHEDULE_SYS_ERROR("703", "系统定时任务执行错误"),
FORM_REPEAT_ERROR("704", "操作次数频繁，请稍后重试"), DATA_VERSION_ERROR("705", "数据写入版本不一致，请稍后重试。"),
REQUEST_PARAM_ILLEGAL_ERROR("706", "请求参数非法"),
DATA_INSERT_ERROR("707", "数据插入失败"),
SCORE_RELEASE_ERROR("708", "积分发放失败，请重试或联系管理员！"),
ENTRY_INTO_FORCE_TIME_SET_ERROR("709", "生效时间不能小于当前时间！"),
INFO_NO_EXISTENCE_OR_STATUS_ERROR("710", "信息不存在或状态有误！"),
// 业务操作错误定义
CUSTOM_ERROR("-1", "自定义业务错误消息"),
FEIGN_ORDER_SERVLET_ERROR("4001", "访问订单服务失败"), FEIGN_USER_SERVLET_ERROR("4002", "访问用户服务失败"),
FEIGN_PAY_SERVLET_ERROR("4003", "访问消耗服务失败"),
DISABLE_ACCOUNT_TOKEN_ERROR("4004", "账号信息变更，登录失效"),
FEIGN_OPERATION_SERVLET_ERROR("4005", "访问行业服务失败"),
ADMIN_ROLE_REPEAT_ERROR("4006", "操作失败，超级管理员和运营管理员有且只有一个"),
FEIGN_FLYER_SERVLET_ERROR("4007", "访问飞手服务失败"),
FEIGN_REPOORDER_SERVLET_ERROR("4008", "访问订单服务失败"),
FEIGN_REPOPAY_SERVLET_ERROR("4009", "访问云仓消耗服务失败"),
FEIGN_REPOUSER_SERVLET_ERROR("4010", "访问云仓用户服务失败"),
FEIGN_WARE_SERVLET_ERROR("4010", "访问云仓商品服务失败"),
FEIGN_DEVICE_SERVLET_ERROR("4011", "访问云仓设备服务失败"),
CENTER_USER_SERVLET_ERROR("4012", "访问用户中心服务失败"), GATEWAY_HYSRIX_ERROR("4013", "服务器貌似在开小差~"),
FEIGN_FLYER_PAY_SERVLET_ERROR("4014", "访问飞手消耗服务失败"),
MALL_USER_SERVLET_ERROR("4015", "访问机城用户服务失败"),
PRIMARY_KEY_DEFECT("5001", "主键ID缺失"),
WALLET_NOT_FIND_ERROR("5002", "钱包账户不存在"),
PARAM_DEFECT("5004", "参数缺失"),
LOGIN_ACCOUNT_NOT_EXIT_ERROR("5005", "账号不存在"),
LOGIN_PASSWORD_ERROR("5006", "密码错误"),
LOGIN_ACCOUNT_STATUS_ERROR("5008", "外部访问"),
OPERATE_USER_ORDERCOUNT_ERROR("5007", "当前账号有存在相关订单未关闭"),
WALLET_CASH_NOT_ENOUGH_ERROR("5009", "现金余额不足"),
AMT_PAID_VERITY_ERROR("5010", "变更额度不在有效范围"),
CREDIT_NOT_ENOUGH_ERROR("5011", "信用余额不足，当前信用余额："),
CREDIT_METHOD_ERROR("5012", "变更类型有误"),
CREDIT_OWED_BEGGER_ERROR("5013", "归还额度不可超过剩余欠款，当前剩余欠款："),
CASH_ADD_OWED_ERROR("5014", "该账号仍有剩余欠款，请先将全部欠款归还后，再进行充值。"),
WALLET_CREDIT_NOT_ENOUGH_ERROR("5015", "信用余额不足"),
ORDER_PAY_FORMAT_ERROR("5016", "现金和信用金额不能同时为空"),
WALLET_CASH_FREEZE_NOT_ENOUGH_ERROR("5017", "现金的冻结余额不足"),
WALLET_CREDIT_FREEZE_NOT_ENOUGH_ERROR("5018", "信用的冻结余额不足"),
ORDER_CASH_FREEZE_NOT_FIND_ERROR("5019", "现金的冻结余额不存在"),
ORDER_CREDIT_FREEZE_NOT_FIND_ERROR("5019", "信用的冻结余额不存在"),
WALLET_BANLANCE_NOT_ENOUGH_ERROR("5020", "现金和信用的余额不足"),
WALLET_FREEZE_NOT_ENOUGH_ERROR("5020", "现金和信用的冻结余额不足"),
CREDIT_REPEAT_NULL_ERROR("5021", "欠款归还不能为空"),
CREDIT_CHANGE_NULL_ERROR("5021", "信用余额变更不能为空"),
ORDER_TOTAL_COST_ERROR("5022", "结算金额不能大于预支付的金额"),
ORDER_PAY_NOT_ENOUGH_ERROR("5023", "总余额不足，订单无法结算"),
NOT_MENU_POWER_ERROR("5024", "当前账号无平台使用权限"),
OPENID_NOT_FIND_ERROR("5025", "OPENID未注册，请登录授权后调用"),
PASSWORD_INCONSISTENT("5026", "新密码与确认密码不一致，请确认一致"),
WX_ACCESS_TOKEN_ERROR("5027", "获取微信AccessToken失败"),
WX_NOT_REL_ERROR("5028", "获取微信公众号用户信息失败"),
WX_NOT_SEND_MSG_PARAM_ERROR("5029", "userId和openId至少一个不为空"),
APPLET_QR_CODE_CREATE_ERROR("5030", "生成小程序码错误："),
APPLET_USER_ACCESS_TOKE_ERROR("5031", "获取accessToken签名校验失败"),
REBATE_AMT_NOT_MIN_ERROR("5032", "金额不足300元无法提现，300元为最低门槛"),
REBATE_AMT_NOT_ENOUGH_ERROR("5033", "申请失败，超过可提现的金额"),
BANK_INFO_NOT_SAVE_ERROR("5034", "请先完善收款账号，才可以申请提现"),
REBATE_APPLY_STATUS_ERROR("5035", "提现状态有误"),
REBATE_INFO_NOT_FIND_ERROR("5036", "提现申请单信息不存在"),
REBATE_FAIL_EXIT_ERROR("5037", "你的收款账号信息有误，请修改信息后重新申请提现。"),
REBATE_AMT_FORMAT_ERROR("5038", "提现金额必须大于0元"),
REBATE_REPEAT_CHECK_ERROR("5039", "提现申请单已被审批，切勿重复审批。"),
CHOOSE_FLYER_NUM_ERROR("5040", "请至少选中一个飞手。"),
CHOOSE_FLYER_MORE_NUM_ERROR("5041", "暂只支持一个订单只能指派一个飞手。"),
ORDER_NO_EXIT_ERROR("5042", "订单信息不存在。"),
ORDER_STATUS_ERROR("5043", "订单状态流程有误。"),
INTERFACE_NOT_INVAILD("5044", "接口已废弃或不存在"),
PAPER_CODE_NOT_INVAILD("5045", "接口已废弃或不存在"),
PHONE_INVAILD_ERROR("5046", "无效的手机号"),
TIME_CODE_INVAILD_ERROR("5047", "无效的时间编码"),
REPEACT_COMMIT_ERROR("5048", "已提交，切勿重复提交"),
IMPORT_EXCEL_ERROR("5049", "excel导入失败"),
REQ_SMS_CODE_ERROR("5050", "注册码格式有误"),
SKU_NOT_PRICE_ERROR("5051", "当前SKU未配置价格"),
SKU_NOT_ENOUGH_ERROR("5052", "套餐（sku）数量不足"),
LEASE_DATE_MATH_ERROR("5053", "租期开始日不能大于结束日"),
ADD_LEASE_ADDR_ERROR("5054", "请选择收货方式"),
SHOP_NEED_PHONE_ERROR("5055", "门店自取需要您的联系电话，请填写联系电话"),
ORDER_POWER_ERROR("5056", "订单不存在或你无权操作该订单"),
ORDER_AUTH_ERROR("5057", "请完成认证再下单"),
EXPRESS_RETURN_ERROR("5058", "请完善物流单号和物流公司"),
SHOP_RETURN_ERROR("5059", "请选择门店"),
ORDER_REFUND_EXIT_ERROR("5060", "该订单已提交过退款申请，请勿重复申请。"),
ORDER_EXPRESS_ERROR("5061", "获取订单物流信息有误。"),
ORDER_PAY_JOB_ERROR("5062", "执行定时任务有误"),
NO_AUTH_ORDER_ERROR("5063", "请完成企业认证或实名认证后再进行下单"),
WARE_NOT_ENOUGH_ERROR("5064", "商品数量不足"),
EX_INFO_ERROR("5065", "物流信息不完善"),
NOT_REAL_AUTH_ERROR("5066", "请完成实名认证后再进行操作"),
REBATE_NOT_ENOUGH_ERROR("5067", "提现申请金额需在10至8000元范围之内"),
MORE_THAN_LIMIT_ERROR("5067", "提现申请金额需在0.1至98000元范围之内"),
FLYER_ENT_MORE_THAN_LIMIT_ERROR("50670", "飞手机构用户银行卡单笔最低10元，最高100,000元"),
FLYER_MORE_THAN_LIMIT_ERROR("50671", "飞手个人用户银行卡单笔最低10元，最高5,000元"),
MORE_THAN_LIMIT_TODAY_ERROR("50672", "单个账户每月提现额度为100,000元"),
SYSTEM_AMT_NOT_ENOUGH_ERROR("5068", "系统处理中，请稍后再试。"),
FEIGN_XZH_SERVLET_ERROR("5069", "访问线上支付接口服务失败"),
XZH_SERVLET_ERROR("5070", "调用线上支付失败："),
XZH_FAIL_ERROR("5071", "支付服务失败："),
REFUSE_COUNT_ERROR("5072", "今日拒绝的次数已达上限，暂不可参与抢单"),
APPLY_ORDER_COUNT_ERROR("5073", "请勿重复接单"),
ORDER_ARRIVE_ERROR("5074", "抢单失败，订单已被指派"),
REST_APPLY_ORDER_ERROR("5075", "请先开启接单状态后再进行抢单"),
EVALUATED_ERROR("5076", "您已经评价过啦!"),
BACKET_TYPE_ERROR("5077", "红包类型有误"),
BACKET_NOT_ENOUGH_ERROR("5078", "红包已被抢光"),
USER_PHONE_AUTH_ERROR("5079", "请授权登录后领取"),
TOKEN_REQUIRED_ERROR("5080", "Please bring a token"),
UNIONID_NOT_ERROR("5081", "UnionId不能为空"),
OPENID_NOT_ERROR("5081", "云享飞openid、云飞手openid、云仓openid、无人机城openid至少要有一个"),
NO_EVALUATED_ERROR("5090", "暂无评价信息!"),
DAY_NUM_ERROR("5091", "天数有误"),
TASK_TYPE_ERROR("5092", "您的账号类型为个人飞手，只能抢任务人数1人的订单。"),
TASK_FLYER_COUNT_LESS_ERROR("5093", "机构认证的飞手多于任务需要的飞手才可以抢单。"),
FLYER_REBATE_ERROR("5094", "提现失败，请稍后重试"),
OPERATION_SYS_ERROR("5095", "操作失败，请稍后重试"),
WAG_CHECK_STATUS_ERROR("5096", "操作失败，未通过或待确认状态才能进行重新编辑"),
EXPORT_NO_DATA_ERROR("5097", "查询到当前符合条件的数据为0条"),
WAG_ZERO_ERROR("5098", "工资抵扣后当月工资不能少于0元"),
WAG_REPEAT_DATE_ERROR("5099", "操作失败，工资日期重复："),
BUY_NUM_ERROR("5100", "购买数量必须大于0"),
SHOP_CAR_ERROR("5101", "购物车信息不存在"),
GOODS_VERSION_ERROR("5102", "操作失败，当前商品已经发生信息变更，请刷新后重试"),
WAG_DETAIL_COUNT_ERROR("5103", "账单天数必须大于0"),
WAG_TERM_PARAM_ERROR("5104", "飞手工资、结算基数、操作三个选项必须填一个"),
IMPORT_PARAM_ERROR("5105", "导入的数据行不能为空或者格式错误"),
SHOP_GOODS_NOT_ERROR("5106", "当前商品已下架或已删除"),
ALL_PAY_ERROR("5107", "当前订单为分期付款，请先上传尾款凭证"),
FLYER_EVLT_PARAM_ERROR("5108", "飞手评分参数有误，请检查"),
FLYER_REPEAT_BIND_ERROR("5108", "飞手已被绑定过，请勿重复绑定"),
FLYER_NUM_BIND_ERROR("5108", "飞手数量有误，本任务需要的飞手人数为："),
FLYER_ORDER_TYPE_ERROR("5110", "飞手类型有误，该订单只允许个人飞手接单"),
FLYER_ENT_ORDER_TYPE_ERROR("5111", "飞手类型有误，该订单只允许飞手机构接单"),
PHONE_NUM_EXIT_ERROR("5112", "手机号已存在"),
FLYER_UN_BIND_ERROR("5113", "飞手已被解绑，请勿重复解绑"),
REPEAT_NOTIFICATION("5114", "您已对此订单进行过催付款操作"),
FLYER_WORK_ERROR("5115", "指派飞手失败，飞手休息中："),
DISABLE_APPLY_ORDER_ERROR("5116", "当前时间此订单不可抢"),
COMPANY_EXIT_ERROR("5117", "单位名称已存在"),
COMPANY_NOT_BIND_ERROR("5118", "未绑定单位，请先绑定单位"),
COMPANY_REMOVE_ERROR("5119", "删除失败，请先移除该单位的账号信息"),
COMPANY_REMOVE_CHILD_ERROR("5120", "删除失败，请先移除该单位的子级单位"),
EXIST_THE_SAME_GOODS_ERROR("5121", "购物车已存在您选择的商品"),
// clientOAuth
OAUTH_CLIENT_NOT_FOUND("6404", "client_id不存在或已注销"),
OAUTH_SECRET_ERROR("6405", "client_secret有误"),
OAUTH_AUTHORIZE_ERROR("6406", "当前账号未获得任何授权，请确认"),
OAUTH_API_AUTH_ERROR("6407", "当前资源未被授权"),
OAUTH_CREATE_TOKEN_ERROR("6408", "系统内部错误，获取accessToken失败，"),
PWD_CREATE_ERROR("6001", "创建密码失败"),
PWD_CONPARED_ERROR("6002", "密码错误"), PWD_ALERT_ERROR("6003", "密码不一致"),
PWD_REQUEST_AUTH_ERROR("6003", "密码请求验证"),
APPLET_PORT_TYPE_ERROR("7001", "小程序端口类型错误"),
APPLET_GET_OPENID_ERROR("7002", "获取小程序openid失败"),
UPDATE_USER_ACCOUNT_REPEAT("7003", "修改后的账户名已存在"), ADD_USER_ACCOUNT_NAME_EXISTS("7004", "新增账户名已经存在"),
ACCOUNT_NOT_FIND_ERROR("8000", "账号信息不存在"),
REPEAT_SOFT_DELETE("8001", "账号已删除"),
ADMIN_ROLE_DELETE_ERROR("8002", "此账号为管理员账号，禁止删除"),
ROLE_ADMIN_DELETE_ERROR("8003", "此角色为管理员角色，禁止删除"),
ROLE_NAME_REPEAT_ERROR("8004", "角色名已存在"),
ROLE_AVL_USER_DELETE_ERROR("8005", "此角色尚有可用账号，请将所有账号移除后在进行操作"),
ROLE_AVL_USER_STATUS_ERROR("8006", "此角色尚有可用账号，请将所有账号禁用后在进行操作"),
ROLE_SYSTEM_DELETE_ERROR("8007", "此角色为系统角色，禁止删除"),
ADMIN_ROLE_POWER_ERROR("8008", "禁止修改管理类角色权限"), SYSTEM_ROLE_POWER_ERROR("8009", "禁止修改系统类角色权限"),
ROLE_SELF_POWER_ERROR("8010", "禁止修改与当前登录账号角色相同的角色权限"),
ADMIN_ACCOUNT_DISABLE_ERROR("8011", "此账号为管理员账号，禁用失败"),
OPERATE_USER_DEL_ERROR("8012", "该账号仍有进行中的订单需要负责，请先移交订单后再删除。"),
OPERATE_USER_DISABLED_ERROR("8013", "该账号仍有进行中的订单需要负责，请先移交订单后再禁用。"),
DELETE_USER_UNFILLED_ORDER_EXIST("9001", "平台中有此账号相关的订单，不可删除此账号"),
STOP_UNFILLED_ORDER_EXIST("9002", "平台中有此账号相关的订单正在进行中，不可停用此账号"),
ACCOUNT_ALREADY_DELETED("10001", "此账号已经被删除"),
ACCOUNT_ALREADY_STOP("10002", "此账号已经被停用,不能登录此小程序，详情请联系管理员"),
INDUSTRY_NAME_CREATE_ERROR("20001", "行业名称请勿重复，请重新输入"),
INSPECTION_NAME_CREATE_ERROR("20002", "服务名称请勿重复，请重新输入"),
INSPECTION_REPEAT("20003", "绑定服务重复"),
INDUSTRY_REPEAT("20004", "绑定行业重复"),
INSERT_INDUSTRY_SUCCESS("20005", "新增行业成功"),
UPDATE_INDUSTRY_SUCCESS("20006", "修改行业成功"),
DELETE_INDUSTRY_SUCCESS("20007", "删除行业成功"),
INSERT_INSPECTION_SUCCESS("20008", "新增服务成功"),
UPDATE_INSPECTION_SUCCESS("20009", "修改服务成功"),
DELETE_INSPECTION_SUCCESS("20010", "删除服务成功"),
SORT_PARAMETER_ERROR("28199", "排序参数错误"),
OPRATING_FREQUENCY_TOO_HIGH("28449", "更新频率过快,请重试"),
INSERT_INDUSTRY_INSPECTION_SUCCESS("20011", "添加对应服务成功"),
INSERT_INSPECTION_INDUSTRY_SUCCESS("20012", "添加对应行业成功"),
DELETE_INDUSTRY_INSPECTION_SUCCESS("20013", "删除对应服务成功"),
DELETE_INSPECTION_INDUSTRY_SUCCESS("20014", "删除对应行业成功"),
INSERT_INDUSTRY_SHELF_SUCCESS("20015", "行业上架成功"),
DELETE_INDUSTRY_SHELF_SUCCESS("20016", "行业下架成功"),
INSERT_INSPECTION_SHELF_SUCCESS("20017", "服务上架成功"),
DELETE_INSPECTION_SHELF_SUCCESS("20018", "服务下架成功"),
DELETE_INSPECTION_ERROR("20022", "该服务仍有未完成的订单，不可删除"),
INSPECTION_NOT_EXIST("20023", "很抱歉，目前该服务已下架"),
FAKE_NUM_CREATE_ERROR("20024", "输入的数据有误，请重新输入！"),
WORK_TYPE_NAME_ERROR("20026", "服务作业类型重复，请重新输入"),
EXIST_BINDING_INSPECTION_ERROR("20027", "此作业类型被服务绑定，删除失败！"),
UPLOAD_IMG_ERROR("20019", "请选择jpg,png,jpeg格式的图片"),
UPLOAD_VIDEO_ERROR("20020", "请选择MP4,avi,mov,mkv格式的视频"),
UPLOAD_DOC_ERROR("20021", "请选择doc,ppt,pdf,xls格式的文件"),
UPLOAD_IMG_LESS_3M_ERROR("20022", "请上传小于3M的图片"),
INSERT_ORDER_SUCCESS("21000", "新增订单成功"),
UPDATE_ORDER_SUCCESS("21001", "修改订单成功"),
ORDER_TRANS_SUCCESS("21002", "订单移交成功"),
ORDER_EVALUATE_SUCCESS("21003", "订单评价完成"),
ORDER_BEFORE_PAY_ERROR("21004", "订单预支付失败"),
ORDER_CLOSE_PAY_ERROR("21005", "订单结算支付失败"),
INSERT_ORDER_DETAIL_SUCCESS("21006", "新增订单动态成功"),
CHECK_USER_ERROR("22001", "用户未通过验证"),
GET_ORDER_LIST_ERROR("22002", "获取订单列表失败"),
COMMANT_CAR_NAME_EXIST("22003", "指挥车名字已存在，请重新输入"),
//认证提示
APP_CODE_ERROR("30301", "appcode 错误"),
REQUE_ENVIROMENT_ERROR("30302", "请求的 Method、Path 或者环境错误"),
REQUEST_PARAMETER_ERROR("30303", "请求参数错误"),
SERVICE_NOT_AUTHORIZED("30304", "服务未被授权（或URL和Path不正确）"),
TIMES_USED_UP("30305", "很抱歉，目前我们的实名认证次数已达上限，正在处理中，请稍后再进行认证。"),
OTHER_ERROR("30306", "其他错误/服务次数用完"),
LIVE_AUTHENTICATION_FAILED("3824", "活体认证失败"),
ID_INFO_AND_ID_card_MISMATCH("3904", "身份信息与身份证不匹配"),
LIVE_AUTHENTICATION_SUCESS("3999", "活体验证成功"),
NO_REAL_NAME("3854", "用户未实名认证"),
URL_FORMAT_ERROR("37462", "URL格式错误"),
URL_ADDRESS_ERROR("36752", "URL地址错误"),
INTERFACE_ACCESS_EXCEPTION("36894", "接口访问异常/次数用尽"),
FRONT_BACK_VAGUE("35556", "身份证正反面不明确"),
ID_CARD_THOTO_MESSAGE_ERROR("36651", "身份照信息错误"),
EXPTION_ID_CARD_THOTO_MESSAGE_ERROR("36651", "信息异常"),
PHOTO_FORMAT_ERROR("12138", "身份证图片格式错误"),
VALIDATION_INFO_EXPIRED("32815", "认证时间过长信息过期或认证信息不完整，请重新开始认证"),
REAL_IMAGE_AUTHENTICATION_SUCESS("38844", "验证成功"),
REAL_IMAGE_AUTHENTICATION_FAILED("38855", "验证失败，请再次进行人脸识别"),
IDENTITY_HAS_BEEN_AUTHENTICATED("34444", "此身份证信息已经被认证，请重试"),
REAL_NAME_ACCOUNT_ID_ERROR("36771", "账户id错误"),
REAL_NAME_FUSING_ERROR("36772", "认证失败，请重新认证"),
//企业认证
BUSINESS_LICENSE_CHECK_ANALYSIS_ERROR("30400", "营业执照解析失败，请上传有效清晰的执照"),
BUSINESS_LICENSE_CHECK_PARAMETER_ERROR("30401", "企业信息与营业执照信息不一致，请重新上传"),
BANK_ACCOUNT_CHECK1_ERROR("30402", "账号与开户名不符"),
BANK_ACCOUNT_CHECK2_ERROR("30403", "开户行名称错误"),
BANK_ACCOUNT_CHECK3_ERROR("30404", "仅支持对公账户验证，不支持个人卡"),
BANK_ACCOUNT_CHECK4_ERROR("30405", "企业账号信息有误，请重新输入"),
BANK_ACCOUNT_CHECK5_ERROR("30406", "24小时之内不能重复申请"),
BANK_ACCOUNT_CHECK6_ERROR("30407", "很抱歉，目前我们的企业认证次数已达上限，如需继续认证请及时联系相关负责人进行处理，联系方式：科比特管理人员，18938853647。"),
BANK_ACCOUNT_CHECK7_ERROR("30408", "企业名称与开户名称不一致，请确认一致后再提交认证"),
ENTERPRISE_HAVE_VERIFIED("30409", "您输入的企业信息已被其他用户认证，请重新输入"),
ID_NUMBER_PARA_ERROR("30410", "身份证号码有错，请重新输入"),
DEAL_ERROR("30411", "有报错，请联系平台客服。"),
NOT_DATA_ERROR("30412", "查无数据"),
API_STOP_USE_ERROR("30413", "接口停用"),
OFFICE_DATA_SUSTAIN_ERROR("30414", "官方数据源维护，请稍候再试"),
SERVER_SUSTAIN_ERROR("30415", "服务商维护，请稍候再试"),
PARA_ERROR("30416", "参数错误，请重新输入"),
VERIFY_COUNT_ERROR("30416", "认证次数上限，请联系管理员"),
NOT_ENT_VERIFY_ERROR("30417", "机构未认证或认证未通过，请先进行机构认证"),
NOT__VERIFY_ERROR("30418", "机构未认证或飞手认证未通过，请先进行认证"),
//渠道认证
NOT_ENT_USER("30501", "感谢您有意向成为我们的渠道商，请先完成企业认证。"),
NEW_NOT_ENT_USER("30502", "此用户未进行企业认证，渠道变更失败！"),
BEFORE_NOT_CHANNEL_USER("30503", "此用户还不是渠道"),
//飞手端认证
NOT_AUTH_FLYER_ERROR("30600", "飞手未认证，请先完成飞手认证"),
NOT_HAVE_AUTH_FLYER_ERROR("30601", "没有认证的飞手，暂不可接单"),
//设备型号提醒
DEVICE_MODEL_REPEAT_ERROR("30700", "产品名称不可重复，请重新输入"),
DEVICE_MODEL_FAILURE_ERROR("30701", "设备添加失败"),
DEVICE_MODEL_REMOVE_ERROR("30702", "设备未在仓库，删除失败"),
DEVICE_MODEL_UPDATE_ERROR("30703", "设备修改失败"),
DEVICE_HAS_BEEN_RENT_ERROR("30704", "该设备不在仓库，不能出库"),
//仓库提醒
REPO_INFO_NAME("30800", "仓库名称不可重复，请重新输入"),
REPO_INFO_FAILURE("30801", "仓库添加失败"),
REPO_INFO_REMOVE("30702", "仓库删除失败"),
//商品
WARE_NAME_HAS_BEEN_EXIST("30900", "商品名称已存在"),
WARE_TYPE_NAME_HAS_BEEN_EXIST("30901", "分类名称已存在"),
WARE_TYPE_ICON_NOT_NULL("30902", "一级分类图标不能为空"),
GROUP_DONT_DELETE("30903", "该分类下尚有商品存在"),
GOODS_STATUS_ERROR("30904", "状态有误"),
GOODS_ON_SHELF_SUCCESS("30905", "商品上架成功"),
GOODS_DOWN_SHELF_SUCCESS("30906", "商品下架成功"),
GOODS_SKU_IS_NOT_NULL("30907", "商品规格不能为空"),
GOODS_PIC_IS_NOT_NULL("30908", "主图不能为空"),
GOODS_DESC_IS_NOT_NULL("30910", "商品描述不能为空"),
GOODS_GROUP_IS_NOT_NULL("30911", "商品类型不能为空"),
GROUP_DONT_DELETE_BY_CHILD("30912", "该分类下尚有子分类存在"),
GOODS_NOT_EXIST_OR_ALREADY_DOWN_SHELF("30913", "商品不存在或已下架"),
GOODS_NAME_IS_NOT_NULL("30914", "商品名称不能为空或名字长度不能大于60"),
GOODS_DELETE_FAIL("30915", "批量删除商品失败,商品已被其他商品绑定"),
BRAND_DELETE_FAIL("30916", "删除失败，产品管理中有产品绑定该品牌名称"),
//返祖
RETURN_SHARE_ORDER_ERROR("40000", "设备返祖订单相关信息找不到，请重新输入订单号"),
RETURN_SHARE_ORDER_NOT_FINISH_ERROR("40001", "此设备的订单未完成，请添加其他设备"),
RETURN_SHARE_ORDER_HAS_BEEN_ADD_ERROR("40002", "此订单的设备已经被添加过，不能重复添加"),
//宣传中心
EXIST_SAME_NAME_OF_MODULE_ERROR("40500", "所属产品中不能有相同名字的模块"),
EXIST_SAME_NAME_OF_BANNER_ERROR("40501", "名称重复，请重新输入"),
EXIST_SAME_CODE_OF_MODULE_ERROR("40502", "moduleCode已重复，请输入其他moduleCode"),
HAS_BEEN_USE_ERROR("40503", "此标签有用户在使用，不能删除！"),
FILE_PARSE_ERROR("40600", "上传文件无数据或内容识别失败，请重新上传"),
HAS_BEEN_APPLY_ERROR("40601", "已提交申请！将有客服人员与你联系"),
PRICE_TO_HIGH_ERROR("40602", "标价确认在0-10000000万元内"),
EXIST_SAME_NAME_ERROR("40603", "快讯名称重复，请重新上传"),
TENDER_FORMAT_ERROR("40604", "招标序号或内容不能为空，请补全后上传"),
TENDER_CONTENT_TOO_LONG_ERROR("40605", "存在招标内容字符过长"),
GOODS_CATEGORY_NAME_EXIST_ERROR("40605", "名称重复，请重新输入!"),
CONTRACT_STATUS_MISTAKEN("40607", "当前合同状态不可进行编辑!"),
CONTRACT_STATUS_CANNOT_BE_DELETED("40607", "当前合同状态不可进行删除!"),
CONTRACT_NOT_EXIST("40608", "合同不存在或已删除!"),
CONTRACT_STATUS_DOES_NOT_ALLOW_FILE("40609", "该状态合同不允许归档!"),
SEAL_INFO_NOT_EXIST("40610", "请前往印章管理上传印章或设置默认印章!"),
AGENCY_NO_FLYER("40611", "机构下暂无飞手，快去招募吧~"),
NO_FLYER_WORK("40612", "现在没有飞手上班哦~"),
TEMPORARY_NOT_SUPPORT_TRANSFER_ORDER("40613", "个人订单暂不支持转单操作~"),
ELECTRONIC_SIGNATURE_NOT_REAL_NAME_AUTHENTICATION("40614", "请完成电子签约实名认证后再进行操作"),
DIRECTORY_DOES_NOT_EXIST("40615", "目录不存在或已删除"),
DEFAULT_DIRECTORY_CANNOT_BE_DEL("40616", "默认目录不可删除"),
THERE_ARE_CATEGORIES_IN_THE_DIRECTORY("40167", "该目录下有分类存在不可删除"),
DIRECTORY_NAME_HAS_BEEN_EXIST("40168", "目录名称已存在"),
FAILED_TO_ADD_DATA("40169", "数据新增失败，请稍后重试"),
FAILED_TO_EDIT_DATA("40170", "数据修改失败，请稍后重试"),
SKU_DOES_NOT_EXIST_OR_HAS_BEEN_DELETED("40171", "sku不存在或已删除，请刷新后重试！"),
SPEC_DOES_NOT_EXIST_OR_HAS_BEEN_DELETED("40172", "规格不存在或已删除，请刷新后重试！"),
SKU_ALREADY_EXIST_IN_THIS_INDUSTRY("40173", "该所属行业下已经存在sku，请检查后重试！"),
SPEC_EXIST_UNDER_THE_SKU("40174", "该sku下有规格存在，无法删除！"),
SPEC_NOT_CONFIG_PRICE("40175", "存在规格没有配置价格，请联系客服获取报价！"),
SHOP_CAR_SIZE_MORE_2("40176", "行业购物车下单数量仅限一个"),
CONTRACT_TEMPLATE_NOT_EXIST_OR_DELETED("40177", "合同模板不存在或已删除！"),
SCORE_ERROR("40177", "您输入的积分数量有误，请重新输入！"),
PLEASE_FILL_IN_THE_CONTRACT_TEMPLATE_FIRST("40178", "请先填充合同模板！"),
SCORE_NOT_GIVE_MYSELF("40179","积分不能转赠给本人,请重新操作"),
ALREADY_FINISH_ENT_AUTH_ERROR("2000", "助力已完成！"),
SYSTEM_ERROR ("2001","系统错误,请稍后重试") ,
RULE_ERROR ("2002","当前兑换比例已失效，请刷新后重试"),
COUNT_LIMIT_ERROR("2003", "参与次数已达上线"),
ALREADY_ENT_AUTH_ERROR("2004","助力失败，您已完成企业认证！"),
ALREADY_REAL_NAME_AUTH_ERROR("2005","助力失败，您已完成实名认证！"),
PARTICIPATE_BUT_NOT_AUTH_ERROR("2006", "待完成授权或认证"),
ALREADY_HELP_ERROR("2007", "已助力"),
ALREADY_STOP_ERROR("2008", "活动已下线"),
HELP_FAIL_ERROR("2009", "不能给自己助力哦！"),
ALREADY_BINDING_ERROR("2010", "优惠券已被绑定"),
ALREADY_DIVIDE_ERROR("2011", "订单已分成"),
DIVIDE_OBJ_NOT_EXIST("2012", "先点击确认添加分成对象");
/**
* 错误码
*
* @return
*/
String resultCode;
/**
* 错误描述
*
* @return
*/
String resultMsg;
ResultEnum(String resultCode, String resultMsg) {
this.resultCode = resultCode;
this.resultMsg = resultMsg;
}
@Override
public String getResultCode() {
return resultCode;
}
@Override
public String getResultMsg() {
return resultMsg;
}
}
src/main/java/com/mmc/oms/common/TDateUtil.java 0 → 100644
package com.mmc.oms.common;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* @Author small
* @Date 2023/5/24 15:36
* @Version 1.0
*/
public class TDateUtil {
public static final String ONE_WEEK = "oneweek";
public static final String ONE_MONTH = "onemonth";
public static final String THREE_MONTH = "threemonth";
public static final String SIX_MONTH = "sixmonth";
public static final String ONE_YEAR = "oneyear";
public static String getCurrentDate() {
SimpleDateFormat df = new SimpleDateFormat("yyyy/MM/dd HH:mm");// 设置日期格式
String date = df.format(new Date());// new Date()为获取当前系统时间
return date;
}
public static String getCurrentDateByType(String format) {
SimpleDateFormat df = new SimpleDateFormat(format);// 设置日期格式
String date = df.format(new Date());// new Date()为获取当前系统时间
return date;
}
public static String getCurrentDateMidd() {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 设置日期格式
String date = df.format(new Date());// new Date()为获取当前系统时间
return date;
}
public static Date getDate(String str, String format) {
Date date = null;
try {
SimpleDateFormat df = new SimpleDateFormat(format);// 设置日期格式
// String dates=df.format(new Date());// new Date()为获取当前系统时间
date = df.parse(str);
} catch (Exception e) {
e.printStackTrace();
}
return date;
}
/**
* date类型转字符串
*/
public static String getDateStr(Date date, String type) {
SimpleDateFormat format = new SimpleDateFormat(type);
String s = format.format(date);
return s;
}
/**
* 根据日期获得随机数
*/
public static Integer getDateRandom(Date date, String format, int count) {
String code = "";
for (int i = 0; i < count; i++) {
code = code + (int) (Math.random() * 9);
}
code = TDateUtil.getDateStr(date, format) + code;
return Integer.parseInt(code);
}
/**
* 10位数的秒转日期字符
*
* @param mss
* @return
*/
public static Date dateFromSecond(long sceondTime) {
return new Date(sceondTime * 1000);
}
/**
* 10位数的秒转日期字符
*
* @param mss
* @return
*/
public static String dateFromSecondStr(long sceondTime) {
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(sceondTime * 1000));
}
/**
* 秒转时分秒
*
* @param secondTime
* @return
*/
public static String hmsFromSecond(Integer secondTime) {
Integer hour = secondTime / 60 / 60;
Integer minutes = secondTime / 60 % 60;
Integer remainingSeconds = secondTime % 60;
return (hour + "h" + minutes + "min" + remainingSeconds + "s");
}
public static String hmsFromSecondFormat(long secondTime) {
long day = secondTime / 60 / 60 / 24;
long hour = secondTime / 60 / 60 % 24;
long minutes = secondTime / 60 % 60;
long remainingSeconds = secondTime % 60;
if (day > 0) {
return (day + "天" + hour + "小时" + minutes + "分" + remainingSeconds + "秒");
}
return (hour + "小时" + minutes + "分" + remainingSeconds + "秒");
}
/**
* 两个日期的相差秒数
*
* @param maxDate
* @param minDate
* @return
*/
public static long calLastedTime(Date maxDate, Date minDate) {
long a = maxDate.getTime();
long b = minDate.getTime();
long c = (a - b) / 1000;
return c;
}
/**
* 获取某个月的月底最后一天的时间
*/
public static Date getMonthLatestDay(Date date) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
// 获取当前月最后一天
Calendar ca = Calendar.getInstance();
ca.setTime(date);
ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
String last = format.format(ca.getTime());
Date dates = getDate(last, "yyyy-MM-dd");
return dates;
}
/**
* 某个时间 加N天
*/
public static Date nextNumDay(Date d, int num) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
try {
Date now = d;
Calendar calendar = Calendar.getInstance();
calendar.setTime(now);
calendar.add(Calendar.DAY_OF_MONTH, num);
String last = format.format(calendar.getTime());
date = getDate(last, "yyyy-MM-dd");
} catch (Exception e) {
e.printStackTrace();
}
return date;
}
/**
* 某天个时间加 N 小时
* @param now
* @param num
* @return
*/
public static Date addHourTime(Date now,int num){
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
try {
Calendar calendar = Calendar.getInstance();
calendar.setTime(now);
calendar.add(Calendar.HOUR,num);
String last = format.format(calendar.getTime());
date = getDate(last, "yyyy-MM-dd HH:mm:ss");
} catch (Exception e) {
e.printStackTrace();
}
return date;
}
/**
* 某个时间加n个月加n天(负数为减)
*/
@SuppressWarnings("static-access")
public static Date getMonthNDayN(Date date, int month, int day) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date news = null;
try {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.MONTH, month);
calendar.add(calendar.DATE, day);
String last = format.format(calendar.getTime());
news = getDate(last, "yyyy-MM-dd");
} catch (Exception e) {
e.printStackTrace();
}
return news;
}
/**
* 时间戳-计算小时
*/
public static long getDistanceTime(long time1, long time2) {
long diff = 0;
long day = 0;
long hour = 0;
if (time1 < time2) {
diff = time2 - time1;
} else {
diff = time1 - time2;
}
day = diff / (24 * 60 * 60 * 1000);
hour = (diff / (60 * 60 * 1000) - day * 24);
return hour;
}
/**
* 两个时间之间相差距离多少天
*
* @param one 时间参数 1：
* @param two 时间参数 2：
* @return 相差天数
*/
public static int distanceDays(Date one, Date two) {
int days = 0;
long time1 = one.getTime();
long time2 = two.getTime();
long diff;
if (time1 < time2) {
diff = time2 - time1;
} else {
diff = time1 - time2;
}
days = new Long(diff / (1000 * 60 * 60 * 24)).intValue();
return days;
}
public static Date nextNumDateTime(Date d, int num) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
try {
Date now = d;
Calendar calendar = Calendar.getInstance();
calendar.setTime(now);
calendar.add(Calendar.DAY_OF_MONTH, num);
String last = format.format(calendar.getTime());
date = getDate(last, "yyyy-MM-dd HH:mm:ss");
} catch (Exception e) {
e.printStackTrace();
}
return date;
}
public static String createYearWeek(String startStr, String endStr) {
if (startStr == null || "".equals(startStr) || endStr == null || "".equals(endStr)) {
return "起止日期不能为空";
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date start = null;
Date end = null;
Date startDate;
Date endDate;
int dayOfWeek;
boolean goOn = true;
int no = 0;
try {
start = sdf.parse(startStr);
end = sdf.parse(endStr);
} catch (ParseException e) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
try {
start = simpleDateFormat.parse(startStr);
end = simpleDateFormat.parse(endStr);
} catch (ParseException pe) {
pe.printStackTrace();
}
}
if (start.compareTo(end) > -1) {
return "结束日期必须大于开始日期";
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(start);
dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
List<Map<String, String>> weekList = new ArrayList<>();
if (dayOfWeek > 1 && dayOfWeek < 7) {
do {
startDate = start;
calendar.add(Calendar.DATE, (8 - dayOfWeek));
endDate = calendar.getTime();
no += 1;
Map<String, String> map = new HashMap<>();
map.put("startOfWeek", sdf.format(startDate));
map.put("weekNo", no + "");
if (endDate.compareTo(end) < 0) {
map.put("endOfWeek", sdf.format(endDate));
weekList.add(map);
calendar.add(Calendar.DATE, 1);
start = calendar.getTime();
dayOfWeek = 2;
} else {
map.put("endOfWeek", sdf.format(end));
weekList.add(map);
goOn = false;
}
} while (goOn);
} else {
no += 1;
startDate = start;
if (dayOfWeek == 1) {
endDate = start;
} else {
calendar.add(Calendar.DATE, 1);
endDate = calendar.getTime();
}
Map<String, String> map = new HashMap<>();
map.put("startOfWeek", sdf.format(startDate));
map.put("endOfWeek", sdf.format(endDate));
map.put("weekNo", no + "");
weekList.add(map);
calendar.add(Calendar.DATE, 1);
start = calendar.getTime();
do {
startDate = start;
calendar.add(Calendar.DATE, 6);
endDate = calendar.getTime();
no += 1;
map = new HashMap<>();
map.put("startOfWeek", sdf.format(startDate));
map.put("weekNo", no + "");
if (endDate.compareTo(end) < 0) {
map.put("endOfWeek", sdf.format(endDate));
weekList.add(map);
calendar.add(Calendar.DATE, 1);
start = calendar.getTime();
} else {
map.put("endOfWeek", sdf.format(end));
weekList.add(map);
goOn = false;
}
} while (goOn);
}
return weekList.toString();
}
/**
* 获取起止日期
*
* @param sdf 需要显示的日期格式
* @param date 需要参照的日期
* @param n 最近n周
* @param option 0 开始日期；1 结束日期
* @param k 0 包含本周 1 不包含本周
* @return
*/
public static String getFromToDate(SimpleDateFormat sdf, Date date, int n, int option, int k) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK) - 1;
int offset = 0 == option ? 1 - dayOfWeek : 7 - dayOfWeek;
int amount = 0 == option ? offset - (n - 1 + k) * 7 : offset - k * 7;
calendar.add(Calendar.DATE, amount);
return sdf.format(calendar.getTime());
}
/**
* 根据当前日期获得最近n周的日期区间（包含本周）
*
* @param n
* @param sdf
* @return
*/
public static String getNWeekTimeInterval(int n, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);// 设置日期格式
String beginDate = getFromToDate(sdf, new Date(), n, 0, 0);
String endDate = getFromToDate(sdf, new Date(), n, 1, 0);
return beginDate + "," + endDate;
}
/**
* 根据当前日期获得最近n周的日期区间（不包含本周）
*
* @param n
* @param sdf
* @return
*/
public static String getNWeekTimeIntervalTwo(int n, String format) {
SimpleDateFormat sdf = new SimpleDateFormat(format);// 设置日期格式
String beginDate = getFromToDate(sdf, new Date(), n, 0, 1);
String endDate = getFromToDate(sdf, new Date(), n, 1, 1);
return beginDate + "," + endDate;
}
/**
* 根据当前日期获得本周的日期区间（本周周一和周日日期）
*
* @param sdf
* @return
*/
public static String getThisWeekTimeInterval(String format) {
return getNWeekTimeInterval(1, format);
}
/**
* 根据当前日期获得上周的日期区间（上周周一和周日日期）
*
* @param sdf
* @return
*/
public static String getLastWeekTimeInterval(String format) {
return getNWeekTimeIntervalTwo(1, format);
}
/**
* 获取某个日期最近一个的星期日
*
* @return
*/
public static Date getLatestWeekend(Date date) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
Date endDate = TDateUtil.nextNumDay(date, w * -1);
return endDate;
}
/**
* 获取N周的星期一的日期(正加负减)
*
* @param date
* @return
*/
public static Date getMinMonday(Date date, int weekNum) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
Date endDate = TDateUtil.nextNumDay(date, w * -1);
Date startDate = TDateUtil.nextNumDay(endDate, (weekNum * 7) + 1);
return startDate;
}
/**
* 获取某个月加几个月后一号的日期
*/
@SuppressWarnings("static-access")
public static Date getAddMonThDay(Date date, int i) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(calendar.MONTH, i);
calendar.set(Calendar.DAY_OF_MONTH, 1);
String last = format.format(calendar.getTime());
date = getDate(last, "yyyy-MM-dd");
return date;
}
/**
* 某个月最后一天
*/
public static Date getAnyMonthLastDay(Date date) {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
// 获取当前月最后一天
Calendar ca = Calendar.getInstance();
ca.setTime(date);
ca.set(Calendar.DAY_OF_MONTH, ca.getActualMaximum(Calendar.DAY_OF_MONTH));
String last = format.format(ca.getTime());
date = getDate(last, "yyyy-MM-dd");
return date;
}
public static Date getDate(Date date, String type) {
SimpleDateFormat format = new SimpleDateFormat(type);
String s = format.format(date);
return getDate(s, type);
}
/**
* 获取去年今天的日期
*/
public static Date getLastYearTodayDate() {
Calendar instance = Calendar.getInstance();
instance.add(Calendar.YEAR,-1);
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
String s = format.format(instance.getTime());
return getDate(s, "yyyy-MM-dd");
}
/**
* 获取昨天的日期
* @param type
* @return
*/
public static String getYesterdayDateByType(String type){
Calendar instance = Calendar.getInstance();
instance.add(Calendar.DAY_OF_MONTH,-1);
Date time = instance.getTime();
SimpleDateFormat format = new SimpleDateFormat(type);
return format.format(time);
}
/**
* 判断两个时间是不是在同一个月
*/
public static boolean isSameMonth(Date date1, Date date2) {
Calendar c = Calendar.getInstance();
c.setTime(date1);
int month1 = c.get(Calendar.MONTH);
c.setTime(date2);
int month2 = c.get(Calendar.MONTH);
if (month1 == month2) {
return true;
}
return false;
}
/**
* 间隔天数
* @param startTime
* @param endTime
* @return
*/
public static int isolateDayNum(String startTime, String endTime){
Date startDate = getDate(startTime, "yyyy-MM-dd");
Date endDate = getDate(endTime, "yyyy-MM-dd");
long differentMillis = endDate.getTime() - startDate.getTime();
long dayNum = differentMillis/(1000*60*60*24);
return (int)dayNum;
}
/**
* 获取某月最后一天的时间
* @param yearMonth
* @return
*/
public static String getLastDateTimeOfMonth(String yearMonth){
SimpleDateFormat format0 = new SimpleDateFormat("yyyy-MM");
SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar instance = Calendar.getInstance();
try {
Date parse = format0.parse(yearMonth);
instance.setTime(parse);
instance.set(Calendar.DAY_OF_MONTH, instance.getActualMaximum(Calendar.DAY_OF_MONTH));
instance.set(Calendar.HOUR_OF_DAY, 23);
instance.set(Calendar.MINUTE, 59);
instance.set(Calendar.SECOND, 59);
String format = format1.format(instance.getTime());
return format;
} catch (Exception e){
e.printStackTrace();
}
return null;
}
public static Date getStrToDate(String str){
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日");
Date date = null;
try {
if (str==null){
date = null;
}else {
date = dateFormat.parse(str);
}
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
public static int getStageByDate(Date date){
Calendar instance = Calendar.getInstance();
instance.setTime(date);
//当前时间
SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
String format = dateFormat.format(date);
try {
Date currentTime = dateFormat.parse(format);
Date parse1 = dateFormat.parse("05:00:00");
Date parse2 = dateFormat.parse("11:00:00");
Date parse3 = dateFormat.parse("17:00:00");
Date parse4 = dateFormat.parse("00:00:00");
//A:05:00-11:00 | B:11:00-17:00 | C:00:00-05:00,17:00-00:00
if (currentTime.after(parse4) && currentTime.before(parse1) ) {
return 3;
}else if (currentTime.after(parse1) && currentTime.before(parse2)) {
return 1;
}else if(currentTime.after(parse2) && currentTime.before(parse3)){
return 2;
}else if(currentTime.after(parse3) && currentTime.after(parse4)){
return 4;
}
}catch (Exception e){
e.printStackTrace();
}
return 0;
}
public static String getCurrentYear(){
Calendar date = Calendar.getInstance();
String year = String.valueOf(date.get(Calendar.YEAR));
return year;
}
}
src/main/java/com/mmc/oms/common/Update.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 14:08
* @Version 1.0
*/
public interface Update {
}
src/main/java/com/mmc/oms/common/WxMsgDataConfig.java 0 → 100644
package com.mmc.oms.common;
/**
* @Author small
* @Date 2023/5/24 16:24
* @Version 1.0
*/
public interface WxMsgDataConfig {
/**
* 用户-信息主页-服务通知-跳转路径
*/
public static final String USER_INFO_PATH = "pages/home/index/index";
/**
* 订单相关-服务通知-跳转路径
*/
public static final String ORDER_PATH = "pages/order/index/index";
/**
*云仓订单发货通知跳转地址
*/
public static final String REPO_SHIP_MESSAGE = "pages/order/index";
/**
* 云仓-首页-跳转路径
*/
public static final String REPO_REBATE_PATH = "pages/home/index";
/**
* 云仓-我的-跳转路径
*/
public static final String REPO_MINE_PATH = "pages/mine/index";
/**
* 云仓-我的-跳转路径
*/
public static final String FLYER_MINE_PATH = "pages/mine/index";
/**
* 企业认证-标题
*/
public static final String ENTPRISE_TITLE = "您的企业信息认证审核结果如下：";
/**
* 渠道申请-服务号-标题
*/
public static final String CHANNEL_FW_TITLE = "您的渠道商申请结果如下：";
/**
* 渠道申请-小程序-标题
*/
public static final String CHANNEL_AT_TITLE = "您的渠道商申请结果如下：";
/**
* 实名认证-标题
*/
public static final String REAL_NAME_TITLE = "实名认证";
/**
* 订单-验收通知说明
*/
public static final String ORDER_FINISH_PAY_REMARK = "验收结算完成";
/**
* 用户端-小程序-首页
*/
public static final String USER_APPLET_PAGE_INDEX = "pages/home/index/index";
/**
* 小程序-提现成功-结果
*/
public static final String REBATE_SUCCESS = "提现成功";
/**
* 小程序-提现失败-结果
*/
public static final String REBATE_FAIL = "提现失败";
/**
* 云仓-提现提示语
*/
public static final String REPO_REBATE_TIPS = "您可以通过云仓小程序查询奖励明细";
/**
* 云飞手-提现提示语
*/
public static final String FLYER_REBATE_TIPS = "您可以通过云飞手小程序查询提现明细";
/**
* 云仓渠道通过页面跳转-小程序
*/
public static final String REPO_CHANNEL_PASS_PATH = "pages/mine/index";
/**
* 无人机城-我的-小程序
*/
public static final String M_ORDER_STATUS_CHANGE_PAGE = "pages/mine/index";
/**
* 无人机城-我的-小程序优惠卷详细页面
*/
public static final String M_ORDER_STATUS_COUPON_DETAILS_PAGE = "page-activity/discount-list/index";
}
src/main/java/com/mmc/oms/config/FlyerSystemConstant.java 0 → 100644
package com.mmc.oms.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* @Author small
* @Date 2023/5/24 16:17
* @Version 1.0
*/
@Component
public class FlyerSystemConstant {
public static String AppletFlyerWxAppid;
public static String AppletFlyerSecret;
public static String WXSubAppId;// 微信公众服务号-appid
public static String WXSubSecret;// 微信公众服务号-密钥
public static String MIMIPROGRAMSTATE;
public static String RABBITMQ_EXCHANGE;
public static String WORK_FLYER_INFO_KEY;
public final static String IS_ADMIN_ROLE = "1";// 为系统管理员类型角色
public FlyerSystemConstant(@Value("${wechat.applet.appid}") String appletFlyerWxAppid,
@Value("${wechat.applet.secret}") String appletFlyerSecret,
@Value("${wechat.sub.appid}") String wXSubAppId, @Value("${wechat.sub.secret}") String wXSubSecret,
@Value("${wechat.applet.miniprogram-state}") String miniprogramState,
@Value("${rabbitmq.exchange}") String rabbitExchange,
@Value("${workFlyerInfoKey}") String workFlyerInfoKey) {
AppletFlyerWxAppid = appletFlyerWxAppid;
AppletFlyerSecret = appletFlyerSecret;
WXSubAppId = wXSubAppId;
WXSubSecret = wXSubSecret;
MIMIPROGRAMSTATE = miniprogramState;
RABBITMQ_EXCHANGE = rabbitExchange;
WORK_FLYER_INFO_KEY = workFlyerInfoKey;
}
}
src/main/java/com/mmc/oms/controller/BaseController.java 0 → 100644
package com.mmc.oms.controller;
import com.mmc.oms.common.AuthHandler;
import com.mmc.oms.jwt.JwtConstant;
import com.mmc.oms.model.dto.BaseAccountDTO;
import com.mmc.oms.model.dto.CurrentUserDTO;
import org.springframework.beans.factory.annotation.Autowired;
import javax.servlet.http.HttpServletRequest;
/**
* @Author small
* @Date 2023/5/24 15:58
* @Version 1.0
*/
public abstract class BaseController {
@Autowired
private AuthHandler authHandler;
/**
* 获取当前用户
*
* @param request
* @return
*/
public CurrentUserDTO getCurrentUser(HttpServletRequest request) {
// 登录未做好-统一通过此方法获取当前用户信息
Integer id = Integer.parseInt(request.getHeader(JwtConstant.USERIDKEY).toString());
Integer roleId = Integer.parseInt(request.getHeader(JwtConstant.ROLEIDKEY).toString());
return CurrentUserDTO.builder().id(id).roleId(roleId).build();
}
/**
* 获取当前登录账号信息
*/
public BaseAccountDTO getCurrentAccount(HttpServletRequest request) {
String token = request.getHeader(JwtConstant.TOKENKEY);
return authHandler.getCurrentAccount(token);
}
}
src/main/java/com/mmc/oms/controller/CouponBackController.java 0 → 100644
package com.mmc.oms.controller;
import com.mmc.oms.common.*;
import com.mmc.oms.model.dto.CouponActivityDTO;
import com.mmc.oms.model.dto.CouponDTO;
import com.mmc.oms.model.dto.CouponUserDTO;
import com.mmc.oms.model.dto.CouponViewDTO;
import com.mmc.oms.model.qo.CouponInfoQO;
import com.mmc.oms.model.qo.CouponUserInfoQO;
import com.mmc.oms.model.qo.ProductCouponQO;
import com.mmc.oms.model.vo.CouponInfoActivityVO;
import com.mmc.oms.model.vo.CouponInfoVO;
import com.mmc.oms.service.CouponBackService;
import io.swagger.annotations.*;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 13:28
* @Version 1.0
*/
@RestController
@RequestMapping("/coupon/back")
@Api(tags = {"优惠券管理后台-相关接口"})
public class CouponBackController {
@Resource
private CouponBackService couponBackService;
@ApiOperation(value = "V1.0.1--新增优惠券")
@ApiResponses({ @ApiResponse(code = 200, message = "OK", response = CouponDTO.class)})
@PostMapping("/save")
public ResultBody<CouponDTO> saveCouponInfo(@RequestParam(value = "file",required = false) MultipartFile file
, @RequestBody CouponInfoVO couponInfoVO){
return couponBackService.saveCouponBackInfo(couponInfoVO,file);
}
@ApiOperation(value = "V1.0.1--新增裂变优惠券")
@ApiResponses({ @ApiResponse(code = 200, message = "OK")})
@PostMapping("/saveActivity")
public ResultBody saveActivityCouponInfo(@Validated(Insert.class) @RequestBody CouponInfoActivityVO couponInfoActivityVO){
return couponBackService.saveActivityCouponInfo(couponInfoActivityVO);
}
@ApiOperation(value = "V1.0.1--优惠券列表-分页")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponDTO.class)})
@PostMapping("/pageList")
public ResultBody pageCouponList(@Validated(Page.class) @RequestBody CouponInfoQO couponInfoQO) {
return couponBackService.pageCouponList(couponInfoQO);
}
@ApiOperation(value = "V1.0.1--裂变优惠券列表-分页")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponActivityDTO.class)})
@PostMapping("/pageActivityList")
public ResultBody pageActivityCouponList(@Validated(Page.class) @RequestBody CouponInfoQO couponInfoQO) {
return couponBackService.pageActivityCouponList(couponInfoQO);
}
@ApiOperation(value = "优惠券-下拉")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponActivityDTO.class)})
@GetMapping("/getActivityCouponPullDown")
public ResultBody getActivityCouponPullDown(@ApiParam(value = "活动类型: 1裂变活动 2普通活动", required = true)
@RequestParam(required = true, value = "type") Integer type) {
return couponBackService.getActivityCouponPullDown(type);
}
@ApiOperation(value = "V1.0.1--增发优惠券")
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/increase")
public ResultBody increaseCoupon(@Validated(Update.class)
@ApiParam(value = "id", required = true)
@RequestParam(required = true, value = "id") Integer id,
@ApiParam(value = "数量", required = true)
@RequestParam(required = true, value = "count") Integer count){
return couponBackService.increaseCouponCount(id, count);
}
@ApiOperation(value = "V1.0.1--关闭优惠券发放")
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/shutDown")
public ResultBody shutDown(@Validated(Update.class)
@ApiParam(value = "id", required = true)
@RequestParam(required = true, value = "id") Integer id){
return couponBackService.shutDown(id);
}
@ApiOperation(value = "V1.0.1--获取优惠券使用数据")
@ApiResponses({@ApiResponse(code = 200, message = "OK",response = CouponViewDTO.class)})
@GetMapping("/getData")
public ResultBody getViewData(@Validated(Query.class)
@ApiParam(value = "id", required = true)
@RequestParam(required = true, value = "id") Integer id){
return couponBackService.couponViewData(id);
}
@ApiOperation(value = "V1.0.1--获取优惠券明细列表")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponUserDTO.class)})
@PostMapping("/getUserCouponList")
public ResultBody getCouponUserList(@Validated(Page.class) @RequestBody CouponUserInfoQO couponUserInfoQO){
return couponBackService.getCouponUserList(couponUserInfoQO);
}
@ApiOperation(value = "V1.0.1--优惠券明细列表-导出")
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/downloadCouponUserList")
public void downloadCouponUserList(@Validated(value = {Others.class}) @RequestBody CouponUserInfoQO couponUserInfoQO,
HttpServletResponse response){
try {
couponBackService.downloadCouponUserList(response,couponUserInfoQO);
} catch (IOException e) {
e.printStackTrace();
}
}
@ApiOperation(value = "feign-获取优惠券详情",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponDTO.class)})
@GetMapping("/feignByIds")
public List<CouponDTO> feignByIds(@RequestParam List<Integer> ids){
return couponBackService.feignByIds(ids);
}
@ApiOperation(value = "feign-获取裂变优惠券详情",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponActivityDTO.class)})
@GetMapping("/feignGetActivity")
public CouponActivityDTO feignGetCouponActivityById(@RequestParam Integer id) {
return couponBackService.getCouponActivityById(id);
}
@ApiOperation(value = "feign-获取裂变优惠券详情-批量",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponActivityDTO.class)})
@PostMapping("/feignGetActivityList")
public List<CouponActivityDTO> feignGetCouponActivityByList(@RequestBody List<Integer> id) {
return couponBackService.getCouponActivityList(id);
}
@ApiOperation(value = "feign-优惠券定时修改状态",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@GetMapping("/feignExpireCoupon")
public void feignExpireCoupon() {
couponBackService.overdueCouponTask();
}
@ApiOperation(value = "feign-根据用户标签获取对应优惠券",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponDTO.class)})
@GetMapping("/feignGetCouponType")
public List<CouponDTO> feignGetCouponType(@RequestParam Integer type) {
return couponBackService.feignGetCouponType(type);
}
@ApiOperation(value = "V2.3.2——商品优惠券普通活动列表")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponDTO.class)})
@PostMapping("/ordinaryActivities")
public ResultBody ordinaryActivities(@Validated(Page.class) @RequestBody ProductCouponQO productCouponQO) {
return couponBackService.ordinaryActivities(productCouponQO);
}
@ApiOperation(value = "V2.3.2——商品优惠券裂变活动列表")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponDTO.class)})
@PostMapping("/fissionActivity")
public ResultBody fissionActivity(@Validated(Page.class) @RequestBody ProductCouponQO productCouponQO) {
return couponBackService.fissionActivity(productCouponQO);
}
}
src/main/java/com/mmc/oms/controller/CouponUserController.java 0 → 100644
package com.mmc.oms.controller;
import com.mmc.oms.common.ResultBody;
import com.mmc.oms.common.Update;
import com.mmc.oms.model.dto.*;
import com.mmc.oms.model.vo.CouponUserExchangeVO;
import com.mmc.oms.model.vo.CouponUserVO;
import com.mmc.oms.service.CouponUserService;
import io.swagger.annotations.*;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:56
* @Version 1.0
*/
@RestController
@RequestMapping("/couponUser/app")
@Api(tags = {"优惠券小程序-相关接口"})
public class CouponUserController extends BaseController {
@Resource
private CouponUserService couponUserService;
@ApiOperation(value = "查看我的优惠卷")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponUserDTO.class)})
@GetMapping("/checkMyCoupon")
public ResultBody getMyCoupon(@ApiParam(value = "状态 1：已使用, 2:已失效，3:已转赠")
@RequestParam(value = "status",required = false) Integer status,
@ApiParam(value = "页码", required = true)
@RequestParam(value = "pageNo") Integer pageNo,
@ApiParam(value = "每页显示数", required = true)
@RequestParam(value = "pageSize") Integer pageSize,
HttpServletRequest request) {
return couponUserService.getMyList(status, pageNo, pageSize, this.getCurrentAccount(request));
}
@ApiOperation(value = "领取优惠券")
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@GetMapping("/receive")
public ResultBody receive(@ApiParam(value = "优惠券id", required = true)
@RequestParam(value = "id") Integer id,
HttpServletRequest request) {
return couponUserService.receiveCoupon(id, this.getCurrentAccount(request));
}
@ApiOperation(value = "转赠优惠券")
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/presented")
public ResultBody presented(@Validated(Update.class)
@ApiParam(value = "优惠券id", required = true)
@RequestParam(value = "id") Integer id,
@ApiParam(value = "用户uid", required = true)
@RequestParam(value = "uid") String uid,
HttpServletRequest request) {
return couponUserService.presentedCoupon(id, uid,this.getCurrentAccount(request));
}
@ApiOperation(value = "获取可领取优惠券列表")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponListDTO.class)})
@GetMapping("/webPageList")
public ResultBody getList(@ApiParam(value = "品牌id 搜索品牌指定优惠卷", required = false)
@RequestParam(value = "productId", defaultValue = "0") List<Integer> productId,
@ApiParam(value = "页码", required = true)
@RequestParam(value = "pageNo") Integer pageNo,
@ApiParam(value = "每页显示数", required = true)
@RequestParam(value = "pageSize") Integer pageSize,
HttpServletRequest request) {
return couponUserService.getList(productId, pageNo, pageSize, this.getCurrentAccount(request));
}
@ApiOperation(value = "feign-根据订单品牌获取可用优惠券",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponUserOrderDTO.class)})
@GetMapping("/feignCoupons")
public List<CouponUserOrderDTO> couponByOrder(@ApiParam(value = "品牌id 搜索品牌指定优惠卷", required = true)
@RequestParam(value = "primaryKey") List<Integer> primaryKey,
@ApiParam(value = "用户id", required = true)
@RequestParam Integer uid) {
return couponUserService.getUsableCoupon(primaryKey,uid);
}
@ApiOperation(value = "feign-根据id查询我的优惠券详情", hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponUserDTO.class)})
@GetMapping("/feignMyCoupons")
private List<CouponUserDTO> feignGetByIds(@ApiParam(value = "id", required = true)
@RequestParam List<Integer> couponIds) {
return couponUserService.feignGetById(couponIds);
}
@ApiOperation(value = "feign-下单修改我的优惠券", hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/feignUpMine")
private Boolean feignUpMyCoupon(@RequestBody List<CouponUserVO> couponUserVO) {
return couponUserService.feignUpMyCoupon(couponUserVO);
}
@ApiOperation(value = "feign-积分兑换优惠券", hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/feignExchange")
private Boolean feignExchangeCoupon(@RequestBody CouponUserExchangeVO couponUserExchangeVO) {
return couponUserService.feignExchangeCoupon(couponUserExchangeVO);
}
@ApiOperation(value = "feign-领取优惠券",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@GetMapping("/feignReceive")
public ResultBody feignReceive(@ApiParam(value = "优惠券id", required = true)
@RequestParam(value = "id") Integer id,
@RequestParam Integer uid,
@RequestParam String uuid,
@RequestParam String phone) {
BaseAccountDTO countDTO = new BaseAccountDTO();
countDTO.setId(uid);
countDTO.setUid(uuid);
countDTO.setAccountPhone(phone);
return couponUserService.receiveCoupon(id, countDTO);
}
@ApiOperation(value = "feign-根据优惠券id查询优惠券",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/feignListUserCouponsByIds")
@ApiIgnore
public List<CouponUserOrderDTO> feignListUserCouponsByIds(@RequestBody List<Integer> couponIds) {
return couponUserService.feignListUserCouponsByIds(couponIds);
}
@ApiOperation(value = "feign-根据订单id查询使用优惠券", hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponUserDTO.class)})
@GetMapping("/feignOrderCoupon")
public List<CouponUserDTO> feignOrderCoupon(@ApiParam(value = "orderId", required = true)
@RequestParam String orderId) {
return couponUserService.feignOrderCoupon(orderId);
}
@ApiOperation(value = "feign-优惠券定时过期",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@GetMapping("/feignExpire")
public void feignExpire() {
couponUserService.overdueTask();
}
@ApiOperation(value = "feign-优惠券回退",hidden = true)
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@PostMapping("/feignRollbackCoupons")
public Boolean feignRollbackCoupons(@RequestBody List<OrderCouponDTO> orderCouponDTOS) {
return couponUserService.feignRollbackCoupons(orderCouponDTOS);
}
@ApiOperation(value = "feign-批量领取优惠券")
@ApiResponses({@ApiResponse(code = 200, message = "OK")})
@GetMapping("/feignReceiveByList")
public ResultBody feignReceiveByList(@ApiParam(value = "优惠券id", required = true)
@RequestParam(value = "id") List<Integer> id,
@RequestParam Integer uid,
@RequestParam String uuid,
@RequestParam String phone) {
BaseAccountDTO countDTO = new BaseAccountDTO();
countDTO.setId(uid);
countDTO.setUid(uuid);
countDTO.setAccountPhone(phone);
return couponUserService.receiveCouponList(id, countDTO);
}
@ApiOperation(value = "V2.3.2-优惠券拥有的商品")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = AppGoodsInfoDTO.class)})
@ApiImplicitParams({
@ApiImplicitParam(name = "couponId", required = false, value = "优惠券id"),
@ApiImplicitParam(name = "productName", required = false, value = "商品名称"),
@ApiImplicitParam(name = "useType", required = false, value = "1vip券, 2品牌券"),
})
@GetMapping("/couponMerchandise")
public ResultBody couponMerchandise(@RequestParam(value = "couponId",required = false) Integer couponId,
@RequestParam(value = "productName",required = false) String productName,
@RequestParam(value = "useType",required = false) Integer useType) {
return couponUserService.couponMerchandise(couponId,productName,useType);
}
@ApiOperation(value = "V2.3.2-优惠券使用明细 ")
@ApiImplicitParams({
@ApiImplicitParam(name = "uid", required = true, value = "领劵人id"),
})
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = CouponUsageDetailsDTO.class)})
@GetMapping("/couponUsageDetails")
public ResultBody couponUsageDetails(@RequestParam(value = "uid",required = true) Integer uid) {
return couponUserService.couponUsageDetails(uid);
}
}
src/main/java/com/mmc/oms/dao/CouponBackDao.java 0 → 100644
package com.mmc.oms.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mmc.oms.entity.CouponDO;
import com.mmc.oms.entity.ProductInformationDo;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 14:44
* @Version 1.0
*/
@Mapper
public interface CouponBackDao extends BaseMapper<CouponDO> {
List<CouponDO> selectCouponList(String date, String priority, Integer pageNo, Integer pageSize);
Integer selectCouponCount(String date, String priority);
ProductInformationDo findProduct(Integer goodsInfoId);
List<CouponDO> ordinaryActivities(Integer brandId);
List<CouponDO> fissionActivity(Integer brandId);
}
src/main/java/com/mmc/oms/dao/CouponUserDao.java 0 → 100644
package com.mmc.oms.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mmc.oms.entity.CouponUsageDetailsDO;
import com.mmc.oms.entity.CouponUserDO;
import com.mmc.oms.entity.GoodsInfoDO;
import com.mmc.oms.model.dto.CouponUserDTO;
import com.mmc.oms.model.qo.CouponUserInfoQO;
import com.mmc.oms.model.vo.CouponUserVO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Set;
/**
* @Author small
* @Date 2023/5/24 15:09
* @Version 1.0
*/
@Mapper
public interface CouponUserDao extends BaseMapper<CouponUserDO> {
List<CouponUserDO> selectCouponUserList(String list, Integer uid, String data);
List<CouponUserDTO> selectCouponUserInfoList(CouponUserInfoQO couponUserInfoQO);
Integer selectCouponUserInfoCount(CouponUserInfoQO couponUserInfoQO);
Integer insertCouponUserOrder(CouponUserVO couponUserVO);
List<Long> getOrderList(Integer id);
void batchRemoveByOIds(@Param("orderIds") Set<Long> orderIds);
List<Integer> merchandise(Integer couponId);
List<GoodsInfoDO> couponMerchandise(List<Integer> merchandise,String productName);
List<CouponUsageDetailsDO> couponUsageDetails(Integer uid);
List<GoodsInfoDO> VipCouponMerchandise(String productName);
}
src/main/java/com/mmc/oms/entity/ChannelCouponDO.java 0 → 100644
package com.mmc.oms.entity;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 14:48
* @Version 1.0
*/
@Getter
@Setter
@EqualsAndHashCode
public class ChannelCouponDO implements Serializable {
private static final long serialVersionUID = 1L;
private String uid;
private String userPhone;
}
src/main/java/com/mmc/oms/entity/CouponDO.java 0 → 100644
package com.mmc.oms.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.mmc.oms.common.CouponConstants;
import com.mmc.oms.model.dto.CouponActivityDTO;
import com.mmc.oms.model.dto.CouponDTO;
import com.mmc.oms.model.dto.CouponListDTO;
import com.mmc.oms.model.vo.CouponInfoActivityVO;
import com.mmc.oms.model.vo.CouponInfoVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import lombok.experimental.Tolerate;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 13:29
* @Version 1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("coupon")
@ApiModel(value="Coupon对象", description="优惠券表")
public class CouponDO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "优惠券ID")
@TableId(value = "id",type = IdType.AUTO)
private Integer id;
@ApiModelProperty(value = "优惠券名称")
private String couponName;
@ApiModelProperty(value = "优惠券面值")
private BigDecimal couponMoney;
@ApiModelProperty(value = "优惠券折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "是否限量, 默认0不限量， 1限量")
private Boolean isLimited;
@ApiModelProperty(value = "每人限制领取张数")
private Integer restrictedAccess;
@ApiModelProperty(value = "发放总数")
private Integer couponTotal;
@ApiModelProperty(value = "剩余数量")
private Integer lastTotal;
/**
* @see
*/
@ApiModelProperty(value = "优惠券类型 1打折券, 2减免券 3无门槛")
private Integer couponType;
@ApiModelProperty(value = "优惠券使用类型 1vip券, 2品牌券")
private Integer useType;
@ApiModelProperty(value = "最低消费")
private BigDecimal minPrice;
@ApiModelProperty(value = "所属 品牌范围id")
private String primaryKey;
/**
* @see
*/
@ApiModelProperty(value = "有效期时间方式：0 固定使用时间, 1领取当日起 2领取次日起")
private Integer isFixedTime;
@ApiModelProperty(value = "有效期时间范围 开始时间")
private Date useStartTime;
@ApiModelProperty(value = "有效期时间范围 结束时间")
private Date useEndTime;
@ApiModelProperty(value = "有效期时间天数")
private Integer couponDay;
/**
* @see
*/
@ApiModelProperty(value = "优惠券发放方式 1 手动领取 2 系统发放 3 批量导入用户")
private Integer getType;
@ApiModelProperty(value = "用户标签")
private Integer userTag;
@ApiModelProperty(value = "状态（0：关闭，1：开启）")
private Boolean couponStatus;
@ApiModelProperty(value = "是否删除 状态（0：否，1：是）")
private Boolean isDel;
@ApiModelProperty(value = "最多优惠")
private BigDecimal preferentialLimit;
@ApiModelProperty(value = "是否多次核销 0单次核销 1多次核销")
private Boolean verificationType;
@TableField(value = "create_time",fill = FieldFill.INSERT_UPDATE)
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "分享者优惠券id")
private Integer parentId;
@ApiModelProperty(value = "分享者-分享人数")
private Integer peopleNumber ;
@ApiModelProperty(value = "批量导入文件url")
private String fileUrl ;
@TableField(exist = false)
@ApiModelProperty(value = "已领取的数量")
private String quantityClaimed ;
public CouponDTO bilIdCouponDTO() {
return CouponDTO.builder().id(this.id).couponName(this.couponName).couponDiscount(this.couponDiscount)
.couponMoney(this.couponMoney).isLimited(this.isLimited).restrictedAccess(this.restrictedAccess)
.couponTotal(this.couponTotal).lastTotal(this.lastTotal).couponType(this.couponType)
.useType(this.useType).minPrice(this.minPrice).primaryKey(this.primaryKey).isFixedTime(this.isFixedTime)
.useStartTime(this.useStartTime).useEndTime(this.useEndTime).couponDay(this.couponDay)
.getType(this.getType).userTag(this.userTag).couponStatus(this.couponStatus).isDel(this.isDel)
.preferentialLimit(this.preferentialLimit).verificationType(this.verificationType).quantityClaimed(this.quantityClaimed)
.createTime(this.createTime).updateTime(this.updateTime).fileUrl(this.fileUrl).build();
}
public CouponListDTO bilIdCouponListDTO() {
return CouponListDTO.builder().id(this.id).couponName(this.couponName).couponDiscount(this.couponDiscount)
.couponMoney(this.couponMoney).isLimited(this.isLimited).restrictedAccess(this.restrictedAccess)
.lastTotal(this.lastTotal).couponType(this.couponType).useType(this.useType).minPrice(this.minPrice)
.primaryKey(this.primaryKey).isFixedTime(this.isFixedTime).useStartTime(this.useStartTime)
.useEndTime(this.useEndTime).couponDay(this.couponDay).getType(this.getType).userTag(this.userTag)
.preferentialLimit(this.preferentialLimit).isUse(false).receivedCount(0).build();
}
public CouponActivityDTO bilIdCouponActivityDTO() {
return CouponActivityDTO.builder().id(this.id).couponName(this.couponName).couponDiscount(this.couponDiscount)
.couponMoney(this.couponMoney).isLimited(this.isLimited).restrictedAccess(this.restrictedAccess)
.couponTotal(this.couponTotal).lastTotal(this.lastTotal).couponType(this.couponType)
.useType(this.useType).minPrice(this.minPrice).primaryKey(this.primaryKey).isFixedTime(this.isFixedTime)
.useStartTime(this.useStartTime).useEndTime(this.useEndTime).couponDay(this.couponDay)
.getType(this.getType).userTag(this.userTag).couponStatus(this.couponStatus)
.verificationType(this.verificationType).createTime(this.createTime).updateTime(this.updateTime)
.parentId(this.parentId).activityRole("share").amountReceived(this.couponTotal - this.lastTotal)
.peopleNumber(this.peopleNumber).build();
}
@Tolerate
public CouponDO(CouponInfoVO payment) {
this.couponName = payment.getCouponName();
this.couponMoney = payment.getCouponMoney();
this.couponDiscount = payment.getCouponDiscount();
this.isLimited = payment.getIsLimited();
this.couponTotal = payment.getCouponTotal();
this.couponType = payment.getCouponType();
this.useType = payment.getUseType();
this.primaryKey = payment.getPrimaryKey();
this.minPrice = payment.getMinPrice();
this.isFixedTime = payment.getIsFixedTime();
this.useStartTime = payment.getUseStartTime();
this.useEndTime = payment.getUseEndTime();
this.couponDay = payment.getCouponDay();
this.getType = payment.getGetType();
this.userTag = payment.getUserTag();
this.restrictedAccess = payment.getRestrictedAccess();
this.preferentialLimit = payment.getPreferentialLimit();
this.verificationType = payment.getVerificationType();
this.fileUrl = payment.getFileUrl();
}
@Tolerate
public CouponDO(CouponInfoActivityVO couponInfoActivityVO){
this.couponName = couponInfoActivityVO.getCouponName();
this.useType = couponInfoActivityVO.getUseType();
this.primaryKey = couponInfoActivityVO.getPrimaryKey();
this.useStartTime = couponInfoActivityVO.getUseStartTime();
this.useEndTime = couponInfoActivityVO.getUseEndTime();
this.couponMoney = couponInfoActivityVO.getCouponMoney();
this.minPrice = couponInfoActivityVO.getMinPrice();
this.couponType = couponInfoActivityVO.getCouponType();
this.couponDiscount = couponInfoActivityVO.getCouponDiscount();
this.verificationType = couponInfoActivityVO.getVerificationType();
this.couponTotal = couponInfoActivityVO.getCouponTotal();
this.restrictedAccess = couponInfoActivityVO.getRestrictedAccess();
this.preferentialLimit = couponInfoActivityVO.getPreferentialLimit();
this.peopleNumber = couponInfoActivityVO.getPeopleNumber();
this.isLimited = true;
this.isFixedTime = CouponConstants.COUPON_USE_TIME_FIXED;
this.getType = CouponConstants.COUPON_USR_TYPE_ACTIVITY;
}
@Tolerate
public CouponDO(CouponInfoActivityVO couponInfoActivityVO, Integer type){
this.couponName = couponInfoActivityVO.getCouponName();
this.useType = couponInfoActivityVO.getBeSharedUseType();
this.primaryKey = couponInfoActivityVO.getBeSharedPrimaryKey();
this.useStartTime = couponInfoActivityVO.getUseStartTime();
this.useEndTime = couponInfoActivityVO.getUseEndTime();
this.couponMoney = couponInfoActivityVO.getBeSharedCouponMoney();
this.minPrice = couponInfoActivityVO.getBeSharedMinPrice();
this.couponType = couponInfoActivityVO.getBeSharedCouponType();
this.couponDiscount = couponInfoActivityVO.getBeSharedCouponDiscount();
this.verificationType = couponInfoActivityVO.getBeSharedVerificationType();
this.couponTotal = couponInfoActivityVO.getBeSharedCouponTotal();
this.preferentialLimit = couponInfoActivityVO.getBeSharedPreferentialLimit();
this.userTag = couponInfoActivityVO.getUserTag();
this.restrictedAccess = 1;
this.isLimited = true;
this.isFixedTime = CouponConstants.COUPON_USE_TIME_FIXED;
this.getType = CouponConstants.COUPON_USR_TYPE_ACTIVITY;
}
}
src/main/java/com/mmc/oms/entity/CouponUsageDetailsDO.java 0 → 100644
package com.mmc.oms.entity;
import com.mmc.oms.model.dto.CouponUsageDetailsDTO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 15:17
* @Version 1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value = "优惠券使用明细", description = "优惠券使用明细")
public class CouponUsageDetailsDO {
private static final long serialVersionUID = 6104334488561632747L;
@ApiModelProperty("id编号")
private Integer id;
@ApiModelProperty("优惠券couponId")
private Integer couponId;
@ApiModelProperty("领劵人id")
private Integer uid;
@ApiModelProperty("开始使用时间")
private Date startTime;
@ApiModelProperty("优惠券名称")
private String couponName;
@ApiModelProperty("状态（0：未使用，1：已使用, 2:已失效，3:已转赠 4:使用中）")
private Integer status;
@ApiModelProperty("核销方式 0单次核销 1多次核销")
private Integer verificationType;
@ApiModelProperty("关联表id")
private Integer couponUserId;
@ApiModelProperty("订单id")
private String orderId;
@ApiModelProperty("订单编码")
private String orderNo;
@ApiModelProperty("剩余余额")
private BigDecimal remainingBalance;
@ApiModelProperty("使用金额")
private BigDecimal useAmount;
@ApiModelProperty("优惠券使用时间")
private Date orderUsageTime;
public CouponUsageDetailsDTO bilIdCouponUsageDetailsDTO() {
return CouponUsageDetailsDTO.builder()
.id(this.id)
.couponId(this.couponId)
.uid(this.uid)
.startTime(this.startTime)
.couponName(this.couponName)
.status(this.status)
.verificationType(this.verificationType)
.couponUserId(this.couponUserId)
.orderId(this.orderId)
.orderNo(this.orderNo)
.remainingBalance(this.remainingBalance)
.useAmount(this.useAmount)
.orderUsageTime(this.orderUsageTime).build();
}
}
src/main/java/com/mmc/oms/entity/CouponUserDO.java 0 → 100644
package com.mmc.oms.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.mmc.oms.common.CouponConstants;
import com.mmc.oms.model.dto.CouponUserDTO;
import com.mmc.oms.model.dto.CouponUserOrderDTO;
import com.mmc.oms.model.vo.CouponUserExchangeVO;
import com.mmc.oms.model.vo.CouponUserVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import lombok.experimental.Tolerate;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:54
* @Version 1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("coupon_user")
@ApiModel(value = "CouponUser对象", description = "用户优惠券记录表")
public class CouponUserDO implements Serializable {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "id")
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
@ApiModelProperty(value = "优惠券id")
private Integer couponId;
@ApiModelProperty(value = "领取人id")
private Integer uid;
@ApiModelProperty(value = "领取人uuid")
private String uuid;
@ApiModelProperty(value = "领取人手机号码")
private String userPhone;
@ApiModelProperty(value = "优惠券名称")
private String couponName;
/**
* @see com.mmc.csf.userpay.constants.CouponConstants
*/
@ApiModelProperty(value = "优惠券类型 1打折券, 2减免券 3无门槛")
private Integer couponType;
/**
* @see com.mmc.csf.userpay.constants.CouponConstants
*/
@ApiModelProperty(value = "优惠券使用类型 1vip券, 2品牌券")
private Integer useType;
@ApiModelProperty(value = "优惠券的面值")
private BigDecimal couponMoney;
@ApiModelProperty(value = "最低消费")
private BigDecimal minPrice;
@ApiModelProperty(value = "优惠券的折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "剩余余额")
private BigDecimal remainingBalance;
/**
* @see com.mmc.csf.userpay.constants.CouponConstants
*/
@ApiModelProperty(value = "获取方式: 用户领取receive, 后台发放send, 赠送presented, 获赠acquire,积分兑换exchange")
private String gainType;
/**
* @see com.mmc.csf.userpay.constants.CouponConstants
*/
@ApiModelProperty(value = "状态（0：未使用,1：已使用, 2:已失效,3:已转赠,4:使用中）")
private Integer status;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "开始使用时间")
private Date startTime;
@ApiModelProperty(value = "过期时间")
private Date endTime;
@ApiModelProperty(value = "使用时间")
private Date useTime;
@ApiModelProperty(value = "所属品牌id")
private String primaryKey;
@ApiModelProperty(value = "兑换比例")
private String conversionRatio;
@ApiModelProperty(value = "转赠人uid")
private String transferorUid;
@ApiModelProperty(value = "获赠人uid")
private String receiveUid;
@ApiModelProperty(value = "转赠时间")
private Date transferorTime;
@ApiModelProperty(value = "是否多次核销 0单次核销 1多次核销")
private Boolean verificationType;
@ApiModelProperty(value = "最多优惠")
private BigDecimal preferentialLimit;
public CouponUserDTO bilIdCouponDTO() {
return CouponUserDTO.builder().id(this.id).couponId(this.couponId).uid(this.uid)
.userPhone(this.userPhone).couponName(this.couponName).couponType(this.couponType).useType(this.useType)
.couponMoney(this.couponMoney).minPrice(this.minPrice).couponDiscount(this.couponDiscount)
.remainingBalance(this.remainingBalance).gainType(this.gainType).status(this.status)
.createTime(this.createTime).updateTime(this.updateTime).startTime(this.startTime)
.endTime(this.endTime).useTime(this.useTime).primaryKey(this.primaryKey)
.conversionRatio(this.conversionRatio).transferorUid(this.transferorUid).receiveUid(this.receiveUid)
.transferorTime(this.transferorTime).verificationType(this.verificationType)
.preferentialLimit(this.preferentialLimit).build();
}
public CouponUserOrderDTO buildCouponUserOrderDTO() {
return CouponUserOrderDTO.builder().id(this.id).couponId(this.couponId).uid(this.uid)
.userPhone(this.userPhone).couponName(this.couponName).couponType(this.couponType).useType(this.useType)
.couponMoney(this.couponMoney).minPrice(this.minPrice).couponDiscount(this.couponDiscount)
.remainingBalance(this.remainingBalance).gainType(this.gainType).status(this.status)
.createTime(this.createTime).startTime(this.startTime).endTime(this.endTime).useTime(this.useTime)
.primaryKey(this.primaryKey).verificationType(this.verificationType)
.preferentialLimit(this.preferentialLimit).validStr("unusable").build();
}
@Tolerate
public CouponUserDO(CouponUserVO couponUserVO) {
this.id = couponUserVO.getId();
this.status = couponUserVO.getStatus();
this.remainingBalance = couponUserVO.getRemainingBalance();
}
@Tolerate
public CouponUserDO(CouponUserExchangeVO couponUserExchangeVO) {
this.uid = couponUserExchangeVO.getUid();
this.uuid = couponUserExchangeVO.getUuid();
this.userPhone = couponUserExchangeVO.getUserPhone();
this.couponName = couponUserExchangeVO.getCouponName();
this.couponMoney = couponUserExchangeVO.getCouponMoney();
this.conversionRatio = couponUserExchangeVO.getConversionRatio();
}
@Tolerate
public CouponUserDO(CouponDO couponDO) {
this.couponId = couponDO.getId();
this.couponName = couponDO.getCouponName();
this.couponType = couponDO.getCouponType();
this.useType = couponDO.getUseType();
this.couponMoney = couponDO.getCouponMoney();
this.minPrice = couponDO.getMinPrice();
this.couponDiscount = couponDO.getCouponDiscount();
this.status = CouponConstants.STORE_COUPON_USER_STATUS_USABLE;
this.primaryKey = couponDO.getPrimaryKey();
this.startTime = couponDO.getUseStartTime();
this.endTime = couponDO.getUseEndTime();
this.verificationType = couponDO.getVerificationType();
this.preferentialLimit = couponDO.getPreferentialLimit();
}
}
src/main/java/com/mmc/oms/entity/GoodsInfoDO.java 0 → 100644
package com.mmc.oms.entity;
import com.mmc.oms.model.dto.AppGoodsInfoDTO;
import com.mmc.oms.model.dto.GoodsInfoListDTO;
import com.mmc.oms.model.dto.GoodsRcdDTO;
import com.mmc.oms.model.dto.TypeGoodsInfoDTO;
import com.mmc.oms.model.vo.CategoryParamAndValueVO;
import com.mmc.oms.model.vo.GoodsAddVO;
import com.mmc.oms.model.vo.MallGoodsAddVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:14
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Accessors(chain = true)
public class GoodsInfoDO implements Serializable {
private static final long serialVersionUID = -1329342381196659417L;
private Integer id;
private Integer pid;
private String goodsNo;
private String goodsName;
private Integer masterTypeId;
private Integer slaveTypeId;
private Integer shelfStatus;
private Integer skuNum;
private Integer deleted;
private Date createTime;
private Date updateTime;
private Integer goodsAttr;
private String ecoLabel;
private Integer goodsCategoryId;
private Integer repoId;
private Integer shareFlyServiceId;
private Integer goodsType;
private Integer sort;
private Integer showCode;
private Integer standardProduct;
private String tag;
/**
* 辅助字段-start
*/
private String videoUrl;
private Integer goodsVideoId;
private String goodsDesc;
// privateGoodsVideoDO goodsVideoDO;
private String mainImg; // 主图
// private GoodsTypeDO goodsMasterType;
// private GoodsTypeDO goodsSlaveType;
private String remark;// 底部备注
private Integer sortTypeId;
private List<CategoryParamAndValueVO> paramAndValue;
// private GoodsConfigExportDO goodsConfigExport;// 功能清单
private Integer buyNum;// 购买数量
private String directoryName;
/**
* 辅助字段-end
*/
public GoodsInfoDO(MallGoodsAddVO mallGoodsAddVO) {
this.id = mallGoodsAddVO.getGoodsInfoVO().getId();
this.goodsName = mallGoodsAddVO.getGoodsInfoVO().getGoodsName();
this.masterTypeId = mallGoodsAddVO.getGoodsInfoVO().getMasterTypeId();
this.slaveTypeId = mallGoodsAddVO.getGoodsInfoVO().getSlaveTypeId();
this.goodsAttr = mallGoodsAddVO.getGoodsInfoVO().getGoodsAttr();
this.ecoLabel = mallGoodsAddVO.getGoodsInfoVO().getGoodsAttr() == 1 ? mallGoodsAddVO.getGoodsInfoVO().getEcoLabel() : null;
this.repoId = mallGoodsAddVO.getGoodsInfoVO().getRepoId() == null ? null : mallGoodsAddVO.getGoodsInfoVO().getRepoId();
this.shareFlyServiceId = mallGoodsAddVO.getGoodsInfoVO().getShareFlyServiceId() == null ? null : mallGoodsAddVO.getGoodsInfoVO().getShareFlyServiceId();
}
// 新版无人机城构造器
public GoodsInfoDO(GoodsAddVO goodsAddVO) {
this.id = goodsAddVO.getId();
this.goodsName = goodsAddVO.getGoodsName();
this.shelfStatus = goodsAddVO.getShelfStatus();
this.masterTypeId = goodsAddVO.getMasterTypeId();
this.slaveTypeId = goodsAddVO.getSlaveTypeId();
this.sortTypeId = goodsAddVO.getSortTypeId();
this.repoId = goodsAddVO.getRepoId();
this.shareFlyServiceId = goodsAddVO.getShareFlyServiceId();
this.tag = goodsAddVO.getTag();
}
public GoodsInfoListDTO buildGoodsInfoListDTO() {
return GoodsInfoListDTO.builder().id(this.id)
.goodsName(this.goodsName)
.status(this.shelfStatus)
.createTime(this.createTime)
.imgUrl(this.mainImg)
.directoryId(this.sortTypeId)
.directoryName(this.directoryName)
.build();
}
public AppGoodsInfoDTO buildAppGoodsInfoDTO() {
return AppGoodsInfoDTO.builder()
.id(this.id)
.goodsName(this.goodsName)
.mainImg(this.mainImg)
.goodsDesc(this.goodsDesc)
.shelfStatus(this.shelfStatus)
.goodsAttr(this.goodsAttr)
.ecoLabel(this.tag)
.showCode(this.showCode)
.sort(this.sort)
.build();
}
public GoodsRcdDTO buildGoodsRcdDTO() {
return GoodsRcdDTO.builder().id(this.id)
.rcdGoodsName(this.goodsName)
.rcdGoodsDescription(this.goodsDesc)
.imgUrl(this.mainImg).build();
}
public TypeGoodsInfoDTO buildTypeGoodsInfoDTO() {
return TypeGoodsInfoDTO.builder().goodsId(this.id)
.goodsImg(this.mainImg).goodsName(this.goodsName)
.showCode(this.showCode).shelfStatus(this.shelfStatus)
.build();
}
}
src/main/java/com/mmc/oms/entity/ProductInformationDo.java 0 → 100644
package com.mmc.oms.entity;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
* @Author small
* @Date 2023/5/24 14:49
* @Version 1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
//@ApiModel(value = "CouponUser对象", description = "用户优惠券记录表")
public class ProductInformationDo {
private Integer goodsInfoId;
private String goodsName;
private String prodSkuSpecName;
private Integer productSkuId;
private String productName;
private Integer brandId;
private String brandName;
}
src/main/java/com/mmc/oms/jwt/JwtConstant.java 0 → 100644
package com.mmc.oms.jwt;
/**
* @Author small
* @Date 2023/5/24 15:59
* @Version 1.0
*/
public interface JwtConstant {
public final static String BASE64KEY = "sharefly@mmc20220616";
public final static String SUBJECT = "cloud_shared_flight_token";
public final static String ISSUER = "mmc";
public final static long EXPIRATION = 1 * 24 * 60 * 60 * 1000L;
public final static long SXTB_PC_LOGIN_INVALID = 1 * 24 * 60 * 60 * 1000L;
public final static String USERIDKEY = "uid";
public final static String ROLEIDKEY = "roleId";
public final static String TOKENKEY = "token";
public final static String TOKEN_TYPE = "TOKEN_TYPE";
public final static String SXTB_ACCOUNT_TOKEN = "SXTB_ACCOUNT_TOKEN";// 神行太保平台平台token
public final static String CSF_USER_ACCOUNT_TOKEN = "USER_ACCOUNT_TOKEN";// 云享飞-用户-token
public final static String CSF_FLYER_ACCOUNT_TOKEN = "FLYER_ACCOUNT_TOKEN";// 飞手-token
public final static String CSF_REPO_ACCOUNT_TOKEN = "REPO_ACCOUNT_TOKEN";// 飞手-token
public final static String MALL_USER_ACCOUNT_TOKEN = "MALL_USER_ACCOUNT_TOKEN";// 商城-token
public final static String OPEN_API_ACCESS_TOKEN = "OPENAPI_ACCESS_TOKEN";// OAUTH-client-token
public final static String AUTHORIZATION = "Authorization";
public final static String GRANT_TYPE = "grant_type";
public final static String CLIENT_CREDENTIALS = "client_credentials";
public final static long OAUTH_EXPIRATION = 1 * 24 * 60 * 60 * 1000L;
public final static String CLIENT_ID_KEY = "MMC_CLIENT_ID_KEY";
public final static String CLIENT_ROLE_KEY = "MMC_CLIENT_ROLE_KEY";
}
src/main/java/com/mmc/oms/jwt/JwtUtil.java 0 → 100644
package com.mmc.oms.jwt;
import com.mmc.oms.common.CodeUtil;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;
import java.security.Key;
import java.util.Date;
import java.util.Map;
/**
* @Author small
* @Date 2023/5/24 16:01
* @Version 1.0
*/
public class JwtUtil {
/**
* 根据map中的信息生成token， tokenId为随机生成码，有效时间为24h
*
* @param claims 封装到token中的map
* @return
*/
public static String createJwt(Map<String, Object> claims) {
return createJwt(claims, JwtConstant.EXPIRATION);
}
public static String createJwt(Map<String, Object> claims, long expiration) {
SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(JwtConstant.BASE64KEY);
Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
long nowMillis = System.currentTimeMillis();
long expMillis = nowMillis + expiration;
Date now = new Date(nowMillis);
Date exp = new Date(expMillis);
JwtBuilder builder = Jwts.builder().setClaims(claims).setId(CodeUtil.randomCode(6)).setIssuedAt(now)
.setSubject(JwtConstant.SUBJECT).setIssuer(JwtConstant.ISSUER).signWith(signatureAlgorithm, signingKey)
.setExpiration(exp);
return builder.compact();
}
/**
* 解析前端传来的token，解析成功则返回Claims,解析失败返回null;解析成功后可通过claims获取信息
*
* @param jwt
* @return
*/
public static Claims parseJwt(String jwt) {
Claims claims = Jwts.parser().setSigningKey(DatatypeConverter.parseBase64Binary(JwtConstant.BASE64KEY))
.parseClaimsJws(jwt).getBody();
return claims;
}
}
src/main/java/com/mmc/oms/model/dto/AppGoodsInfoDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:47
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.dto.AppGoodsInfoDTO", description = "小程序商品信息DTO")
public class AppGoodsInfoDTO implements Serializable {
private static final long serialVersionUID = 6104334488561632747L;
@ApiModelProperty("商品id")
private Integer id;
@ApiModelProperty("商品名称")
private String goodsName;
@ApiModelProperty("商品上架状态")
private Integer shelfStatus;
@ApiModelProperty("商品主图")
private String mainImg;
@ApiModelProperty("商品描述")
private String goodsDesc;
@ApiModelProperty("商品属性")
private Integer goodsAttr;
@ApiModelProperty("生态标签")
private String ecoLabel;
@ApiModelProperty("安全编码")
private String code;
@ApiModelProperty("排序")
private Integer sort;
@ApiModelProperty("安全编码是否显示 0 否 1 是")
private Integer showCode;
}
src/main/java/com/mmc/oms/model/dto/BaseAccountDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 14:56
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.BaseAccountDTO", description = "登录信息DTO")
public class BaseAccountDTO implements Serializable {
private static final long serialVersionUID = -2979712090903806216L;
private Integer id;
private String uid;
private String accountPhone;
private String accountNo;
private String accountName;
private String tokenPort;
@ApiModelProperty(value = "角色ID")
private Integer roleId;
@ApiModelProperty(value = "是否为管理角色:0否 1是")
private Integer admin;// 是否为管理角色
@ApiModelProperty(value = "是否为运营角色:0否 1是")
private Integer operate;
@ApiModelProperty(value = "是否PMC发货专员:0否 1是")
private Integer pmc;
@ApiModelProperty(value = "单位信息")
private CompanyCacheDTO companyInfo;// 单位信息
public BaseAccountDTO(UserAccountDTO user) {
this.id = user.getId();
this.accountNo = user.getAccountNo();
this.accountName = user.getUserName();
this.roleId = user.getRoleInfo() == null ? null : user.getRoleInfo().getId();
this.admin = user.getRoleInfo() == null ? null : user.getRoleInfo().getAdmin();
this.operate = user.getRoleInfo() == null ? null : user.getRoleInfo().getOperate();
this.pmc = user.getRoleInfo() == null ? null : user.getRoleInfo().getPmc();
}
public BaseAccountDTO(RepoAccountDTO account) {
this.id = account.getId();
this.accountName = account.getAccountName();
this.uid = account.getUid();
this.accountPhone = account.getPhoneNum();
}
public BaseAccountDTO(MallUserDTO account) {
this.id = account.getId();
this.accountName = account.getNickName();
this.uid = account.getUid();
this.accountPhone = account.getPhoneNum();
}
public BaseAccountDTO(FlyerAccountDTO account) {
this.id = account.getId();
this.accountName = account.getAccountName();
this.uid = account.getUid();
this.accountPhone = account.getPhoneNum();
}
/**
* 是否为科比特超级管理员单位(是:无单位资源限制 否:只能看当前和下级单位的资源)
* @return
*/
public boolean isManage() {
if(this.getCompanyInfo()==null){
return false;
}
if(this.getCompanyInfo().getManage()==null){
return false;
}
return this.getCompanyInfo().getManage() == 1;
}
/**
* 判断是否已授权
*
* @return
*/
// public boolean authorized() {
// if (StringUtils.isBlank(this.accountName) || StringUtils.isBlank(this.accountPhone)) {
// return false;
// }
// return true;
// }
}
src/main/java/com/mmc/oms/model/dto/CompanyCacheDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 14:57
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CompanyCacheDTO implements Serializable {
@ApiModelProperty(value = "单位ID")
private Integer id;
@ApiModelProperty(value = "单位名称")
private String company;
@ApiModelProperty(value = "是否为管理单位：0否 1是",hidden = true)
private Integer manage;
@ApiModelProperty(value = "当前单位ID+子级单位ID的集合",hidden = true)
private List<Integer> companys;
}
src/main/java/com/mmc/oms/model/dto/CompanySimpleDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 14:57
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.sharefly.dto.CompanySimpleDTO", description = "单位信息DTO")
public class CompanySimpleDTO implements Serializable {
private static final long serialVersionUID = 2541404541696571857L;
@ApiModelProperty(value = "单位ID")
private Integer id;
@ApiModelProperty(value = "单位名称")
private String company;
@ApiModelProperty(value = "账号类型:0合伙人 1员工")
private Integer userType;
@ApiModelProperty(value = "是否为管理单位：0否 1是",hidden = true)
private Integer manage;
@ApiModelProperty(value = "当前单位ID+子级单位ID的集合",hidden = true)
private List<Integer> companys;
}
src/main/java/com/mmc/oms/model/dto/CouponActivityDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:05
* @Version 1.0
*/
@Builder
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="CouponActivity对象", description="裂变优惠券")
@AllArgsConstructor
@NoArgsConstructor
public class CouponActivityDTO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "优惠券ID")
private Integer id;
@ApiModelProperty(value = "优惠券名称")
private String couponName;
@ApiModelProperty(value = "优惠券面值")
private BigDecimal couponMoney;
@ApiModelProperty(value = "优惠券折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "是否限量, 默认0不限量， 1限量")
private Boolean isLimited;
@ApiModelProperty(value = "每人限制领取张数")
private Integer restrictedAccess;
@ApiModelProperty(value = "发放总数")
private Integer couponTotal;
@ApiModelProperty(value = "剩余数量")
private Integer lastTotal;
@ApiModelProperty(value = "已领取数量")
private Integer amountReceived;
@ApiModelProperty(value = "优惠券类型 1打折卷, 2减免券 3无门槛")
private Integer couponType;
@ApiModelProperty(value = "优惠券使用类型 1vip券, 2品牌券")
private Integer useType;
@ApiModelProperty(value = "最低消费")
private BigDecimal minPrice;
@ApiModelProperty(value = "所属 品牌范围id")
private String primaryKey;
@ApiModelProperty(value = "有效期时间方式：0 固定使用时间, 1领取当日起 2领取次日起")
private Integer isFixedTime;
@ApiModelProperty(value = "有效期时间范围 开始时间")
private Date useStartTime;
@ApiModelProperty(value = "有效期时间范围 结束时间")
private Date useEndTime;
@ApiModelProperty(value = "有效期时间天数")
private Integer couponDay;
@ApiModelProperty(value = "优惠券类型 1 手动领取 2 系统发放 3 批量导入用户 4活动领取")
private Integer getType;
@ApiModelProperty(value = "用户标签")
private Integer userTag;
@ApiModelProperty(value = "是否单次核销 0单次核销 1多次核销")
private Boolean verificationType;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "状态（0：关闭，1：开启）")
private Boolean couponStatus;
@ApiModelProperty(value = "分享者优惠券id")
private Integer parentId;
@ApiModelProperty(value = "分享者分享人数")
private Integer peopleNumber;
@ApiModelProperty(value = "角色 share分享者 beShare被分享者")
private String activityRole;
@ApiModelProperty(value = "被分享者优惠券")
private CouponActivityDTO beSharedCoupon;
}
src/main/java/com/mmc/oms/model/dto/CouponDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 13:59
* @Version 1.0
*/
@Builder
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="Coupon对象", description="优惠券表")
@NoArgsConstructor
@AllArgsConstructor
public class CouponDTO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "优惠券ID")
private Integer id;
@ApiModelProperty(value = "优惠券名称")
private String couponName;
@ApiModelProperty(value = "优惠券面值")
private BigDecimal couponMoney;
@ApiModelProperty(value = "优惠券折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "是否限量, 默认0不限量， 1限量")
private Boolean isLimited;
@ApiModelProperty(value = "每人限制领取张数")
private Integer restrictedAccess;
@ApiModelProperty(value = "发放总数")
private Integer couponTotal;
@ApiModelProperty(value = "剩余数量")
private Integer lastTotal;
@ApiModelProperty(value = "优惠券类型 1打折卷, 2减免券 3无门槛")
private Integer couponType;
@ApiModelProperty(value = "优惠券使用类型 1vip券, 2品牌券")
private Integer useType;
@ApiModelProperty(value = "最低消费")
private BigDecimal minPrice;
@ApiModelProperty(value = "所属 品牌范围id")
private String primaryKey;
@ApiModelProperty(value = "有效期时间方式：0 固定使用时间, 1领取当日起 2领取次日起")
private Integer isFixedTime;
@ApiModelProperty(value = "有效期时间范围 开始时间")
private Date useStartTime;
@ApiModelProperty(value = "有效期时间范围 结束时间")
private Date useEndTime;
@ApiModelProperty(value = "有效期时间天数")
private Integer couponDay;
@ApiModelProperty(value = "优惠券类型 1 手动领取 2 系统发放 3 批量导入用户 4活动裂变券")
private Integer getType;
@ApiModelProperty(value = "用户标签 1新人 2实名认证 3企业认证")
private Integer userTag;
@ApiModelProperty(value = "状态（0：关闭，1：开启）")
private Boolean couponStatus;
@ApiModelProperty(value = "是否删除 状态（0：否，1：是）")
private Boolean isDel;
@ApiModelProperty(value = "最多优惠")
private BigDecimal preferentialLimit;
@ApiModelProperty(value = "是否多次核销 0单次核销 1多次核销")
private Boolean verificationType;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "批量导入文件url")
private String fileUrl;
@ApiModelProperty(value = "已领取的数量")
private String quantityClaimed ;
}
src/main/java/com/mmc/oms/model/dto/CouponListDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:06
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
//@ApiModel(value="CouponList对象", description="小程序优惠券表")
public class CouponListDTO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "优惠券ID")
private Integer id;
@ApiModelProperty(value = "优惠券名称")
private String couponName;
@ApiModelProperty(value = "优惠券面值")
private BigDecimal couponMoney;
@ApiModelProperty(value = "优惠券折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "是否限量, 默认0不限量， 1限量")
private Boolean isLimited;
@ApiModelProperty(value = "每人限制领取张数")
private Integer restrictedAccess;
@ApiModelProperty(value = "剩余数量")
private Integer lastTotal;
@ApiModelProperty(value = "优惠券类型 1打折卷, 2减免券 3无门槛")
private Integer couponType;
@ApiModelProperty(value = "优惠券使用类型 1vip券, 2品牌券")
private Integer useType;
@ApiModelProperty(value = "最低消费")
private BigDecimal minPrice;
@ApiModelProperty(value = "所属 品牌范围id")
private String primaryKey;
@ApiModelProperty(value = "有效期时间方式：0 固定使用时间, 1领取当日起 2领取次日起")
private Integer isFixedTime;
@ApiModelProperty(value = "有效期时间范围 开始时间")
private Date useStartTime;
@ApiModelProperty(value = "有效期时间范围 结束时间")
private Date useEndTime;
@ApiModelProperty(value = "有效期时间天数")
private Integer couponDay;
@ApiModelProperty(value = "优惠券类型 1 手动领取 2 系统发放 3 批量导入用户 4活动领取")
private Integer getType;
@ApiModelProperty(value = "用户标签")
private Integer userTag;
@ApiModelProperty(value = "最多优惠")
private BigDecimal preferentialLimit;
@ApiModelProperty(value = "是否已领取未使用")
private Boolean isUse = false;
@ApiModelProperty(value = "已经领取数量")
private Integer receivedCount = 0;
}
src/main/java/com/mmc/oms/model/dto/CouponUsageDetailsDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 15:17
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.dto.CouponUsageDetailsDTO", description = "优惠券使用明细DTO")
public class CouponUsageDetailsDTO {
private static final long serialVersionUID = 6104334488561632747L;
@ApiModelProperty("id编号")
private Integer id;
@ApiModelProperty("优惠券id")
private Integer couponId;
@ApiModelProperty("领劵人id")
private Integer uid;
@ApiModelProperty("开始使用时间")
private Date startTime;
@ApiModelProperty("优惠券名称")
private String couponName;
@ApiModelProperty("状态（0：未使用，1：已使用, 2:已失效，3:已转赠 4:使用中）")
private Integer status;
@ApiModelProperty("核销方式 0单次核销 1多次核销")
private Integer verificationType;
@ApiModelProperty("关联表id")
private Integer couponUserId;
@ApiModelProperty("订单id")
private String orderId;
@ApiModelProperty("订单编码")
private String orderNo;
@ApiModelProperty("剩余余额")
private BigDecimal remainingBalance;
@ApiModelProperty("使用金额")
private BigDecimal useAmount;
@ApiModelProperty("优惠券使用时间")
private Date orderUsageTime;
}
src/main/java/com/mmc/oms/model/dto/CouponUserDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import cn.afterturn.easypoi.excel.annotation.ExcelTarget;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 14:09
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value="CouponUser对象", description="用户优惠券DTO表")
@ExcelTarget("couponUserExcel")
public class CouponUserDTO implements Serializable {
private static final long serialVersionUID = 7665462964438044885L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "优惠券id")
private Integer couponId;
@JsonSerialize(using= ToStringSerializer.class)
@ApiModelProperty(value = "订单id")
private Long cid;
@ApiModelProperty(value = "订单编码")
private String orderNo;
@ApiModelProperty(value = "领取人id")
private Integer uid;
@ApiModelProperty(value = "领取人uuid")
private String uuid;
@ApiModelProperty(value = "领取人手机号码")
private String userPhone;
@ApiModelProperty(value = "优惠券名称")
private String couponName;
@ApiModelProperty(value = "优惠券类型 1打折券, 2减免券 3无门槛")
private Integer couponType;
@ApiModelProperty(value = "优惠券使用类型 1vip券, 2品牌券")
private Integer useType;
@ApiModelProperty(value = "优惠券的面值")
private BigDecimal couponMoney;
@ApiModelProperty(value = "最低消费")
private BigDecimal minPrice;
@ApiModelProperty(value = "优惠券的折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "剩余余额")
private BigDecimal remainingBalance;
@ApiModelProperty(value = "获取方式，1 后台发放, 2 用户领取, 3赠送 4获赠")
private String gainType;
@ApiModelProperty(value = "状态（0：未使用,1：已使用, 2:已失效,3:已转赠,4:使用中）")
private Integer status;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "开始使用时间")
private Date startTime;
@ApiModelProperty(value = "过期时间")
private Date endTime;
@ApiModelProperty(value = "使用时间")
private Date useTime;
@ApiModelProperty(value = "所属品牌id")
private String primaryKey;
@ApiModelProperty(value = "兑换比例")
private String conversionRatio;
@ApiModelProperty(value = "转赠人uid")
private String transferorUid;
@ApiModelProperty(value = "获赠人uid")
private String receiveUid;
@ApiModelProperty(value = "转赠时间")
private Date transferorTime;
@ApiModelProperty(value = "是否多次核销 0单次核销 1多次核销")
private Boolean verificationType;
@ApiModelProperty(value = "最多优惠")
private BigDecimal preferentialLimit;
@ApiModelProperty(value = "所属品牌id")
private List<String> brandIds;
@ApiModelProperty(value = "可打折金额")
private BigDecimal discountCouponPrice;
}
src/main/java/com/mmc/oms/model/dto/CouponUserOrderDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 14:46
* @Version 1.0
*/
@Builder
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
//@ApiModel(value="CouponUser对象", description="下单可用用户优惠券DTO表")
@NoArgsConstructor
@AllArgsConstructor
public class CouponUserOrderDTO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "优惠券id")
private Integer couponId;
@ApiModelProperty(value = "订单id")
private Long cid;
@ApiModelProperty(value = "领取人id")
private Integer uid;
@ApiModelProperty(value = "领取人手机号码")
private String userPhone;
@ApiModelProperty(value = "优惠券名称")
private String couponName;
@ApiModelProperty(value = "优惠券类型 1打折券, 2减免券 3无门槛")
private Integer couponType;
@ApiModelProperty(value = "优惠券使用类型 1vip券, 2品牌券")
private Integer useType;
@ApiModelProperty(value = "优惠券的面值")
private BigDecimal couponMoney;
@ApiModelProperty(value = "最低消费")
private BigDecimal minPrice;
@ApiModelProperty(value = "优惠券的折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "剩余余额")
private BigDecimal remainingBalance;
@ApiModelProperty(value = "获取方式，1 后台发放, 2 用户领取, 3赠送 4获赠")
private String gainType;
@ApiModelProperty(value = "状态（0：未使用,1：已使用, 2:已失效,3:已转赠,4:使用中）")
private Integer status;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "开始使用时间")
private Date startTime;
@ApiModelProperty(value = "过期时间")
private Date endTime;
@ApiModelProperty(value = "使用时间")
private Date useTime;
@ApiModelProperty(value = "所属品牌id")
private String primaryKey;
@ApiModelProperty(value = "是否多次核销 0单次核销 1多次核销")
private Boolean verificationType;
@ApiModelProperty(value = "最多优惠")
private BigDecimal preferentialLimit;
@ApiModelProperty(value = "有效状态：usable-可用，unusable-不可用，默认不可用")
private String validStr;
@ApiModelProperty(value = "所属品牌id")
private List<String> brandIds;
@ApiModelProperty(value = "可打折金额")
private BigDecimal discountCouponPrice;
@ApiModelProperty(value = "推荐使用")
private Integer recommend;
}
src/main/java/com/mmc/oms/model/dto/CouponViewDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 14:09
* @Version 1.0
*/
@Data
@ApiModel(value="用户优惠券使用数据", description="用户优惠券使用数据DTO")
public class CouponViewDTO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "总发行量")
private Integer couponTotal;
@ApiModelProperty(value = "领取量")
private Long receiveQuantity;
@ApiModelProperty(value = "领取率")
private String claimRate;
@ApiModelProperty(value = "使用量")
private Integer usageAmount;
@ApiModelProperty(value = "有效使用量")
private Integer accountPaid;
@ApiModelProperty(value = "有效使用率")
private String availability;
}
src/main/java/com/mmc/oms/model/dto/CurrentUserDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:58
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CurrentUserDTO implements Serializable {
private static final long serialVersionUID = -2302598593780513593L;
private Integer id;
private Integer roleId;
}
src/main/java/com/mmc/oms/model/dto/FlyerAccountDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import com.mmc.oms.common.FlyerAccountType;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Set;
/**
* @Author small
* @Date 2023/5/24 14:59
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "com.mmc.csf.model.dto.FlyerAccountDTO", description = "飞手端用户DTO")
public class FlyerAccountDTO implements Serializable {
private static final long serialVersionUID = -5663270547201316327L;
@ApiModelProperty(value = "飞手端用户id")
private Integer id;
@ApiModelProperty(value = "飞手端用户uid")
private String uid;
@ApiModelProperty(value = "飞手端用户名称")
private String accountName;
@ApiModelProperty(value = "联系电话")
private String phoneNum;
@ApiModelProperty(value = "飞手端用户类型，（个人飞手，机构）")
private Integer accountType;
@ApiModelProperty(value = "实名认证状态")
private Integer realAuthStatus;
@ApiModelProperty(value = "企业认证状态")
private Integer entAuthStatus;
@ApiModelProperty(value = "工作状态")
private Integer workStatus;
@ApiModelProperty(value = "常驻城市")
private String resAddress;
@ApiModelProperty(value = "openId")
private String openId;
@ApiModelProperty(value = "unionId")
private String unionId;
@ApiModelProperty(value = "昵称")
private String nickName;
@ApiModelProperty(value = "头像url")
private String headerImg;
@ApiModelProperty(value = "经度")
private Double lon;
@ApiModelProperty(value = "纬度")
private Double lat;
@ApiModelProperty(value = "备注")
private String remark;
@ApiModelProperty(value = "删除状态，0未删除，1删除")
private Integer deleted;
@ApiModelProperty(value = "企业名称")
private String entName;
@ApiModelProperty(value = "生成时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "有无订单：0无,1有")
private Integer serviceStatus;
@ApiModelProperty(value = "距离订单距离-单位km")
private Double orderDist;
@ApiModelProperty(value = "服务中的订单名称")
private List<String> orderNames;
@ApiModelProperty(value = "飞手认证状态")
private Integer licStatus;
@ApiModelProperty(value = "机构信息")
private FlyerEntInfoDTO entInfo;
@ApiModelProperty(value = "抢单状态-0否-1是")
private Integer applyOrder;
@ApiModelProperty(value = "多端用户，USER_PORT(云享飞)-FLYER_PORT(云飞手)-REPO_PORT(云仓)")
private Set<String> ports;
@ApiModelProperty(value = "推荐人ID")
private Integer rcdFlyerAccountId;
@ApiModelProperty(value = "推荐人昵称")
private String rcdNickName;
@ApiModelProperty(value = "推荐人uid")
private String rcdUid;
@ApiModelProperty(value = "推荐人账号名称")
private String rcdAccountName;
@ApiModelProperty(value = "已推荐用户数")
private Integer rcdUserNumber;
@ApiModelProperty(value = "是否销售")
private Integer sale;
@ApiModelProperty(value = "是否白名单")
private Integer white;
@ApiModelProperty(value = "用户来源：0自然流，1海报，2抖音，3公众号，4社群，5招投标，默认0")
private Integer source;
@ApiModelProperty(value = "订单信息")
private FlyerOrderTaskDTO flyerOrderTask;
@ApiModelProperty(value = "场景认证信息")
private FlyerScenesAuthDTO flyerScenesAuth;
/**
* 是否为飞手机构用户
*
* @return
*/
public boolean checkFlyerEnt() {
return (FlyerAccountType.JG.getCode().toString().equals(this.accountType.toString()));
}
/**
* 是否为飞手个人用户
*
* @return
*/
public boolean checkFlyer() {
return (FlyerAccountType.GR.getCode().toString().equals(this.accountType.toString()));
}
}
src/main/java/com/mmc/oms/model/dto/FlyerEntInfoDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:59
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.FlyerEntInfoDTO", description = "飞手机构DTO")
public class FlyerEntInfoDTO implements Serializable {
private static final long serialVersionUID = -3064900348178903673L;
@ApiModelProperty(value = "机构id")
private Integer id;
@ApiModelProperty(value = "飞手端用户id")
private Integer flyerAccountId;
@ApiModelProperty(value = "机构名称")
private String entName;
@ApiModelProperty(value = "机构认证审批状态")
private Integer entCheckStatus;
@ApiModelProperty(value = "机构法人名称")
private String entLegalPerson;
@ApiModelProperty(value = "社会统一信用码")
private String uscCode;
@ApiModelProperty(value = "营业执照url")
private String unLicImg;
@ApiModelProperty(value = "开户银行")
private String bankName;
@ApiModelProperty(value = "账户名称")
private String accountHolder;
@ApiModelProperty(value = "银行账号")
private String bankAccount;
@ApiModelProperty(value = "法人身份证号")
private String idNumber;
@ApiModelProperty(value = "机构备注")
private String remark;
@ApiModelProperty(value = "生成时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "飞手总数")
private Integer sumOfFlyer;
@ApiModelProperty(value = "认证飞手数")
private Integer countOfAuthFlyer;
@ApiModelProperty(value = "用户uid")
private String uid;
@ApiModelProperty(value = "用户手机号")
private String phoneNum;
@ApiModelProperty(value = "常驻城市")
private String resAddress;
@ApiModelProperty(value = "昵称")
private String nickName;
}
src/main/java/com/mmc/oms/model/dto/FlyerOrderTaskDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:01
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class FlyerOrderTaskDTO implements Serializable {
private static final long serialVersionUID = 4288411060058354326L;
private Integer id;
private Integer orderId;
private Integer flyerAccountId;
private Integer orderType;
private Integer virtualTeamId;
private String orderName;
private String orderNo;
public FlyerOrderTaskDTO(OrderTaskDTO d) {
this.orderId = d.getId();
this.orderName = d.getOrderName();
this.orderNo = d.getOrderNo();
}
}
src/main/java/com/mmc/oms/model/dto/FlyerScenesAuthDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:06
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class FlyerScenesAuthDTO implements Serializable {
private static final long serialVersionUID = 66032902942031710L;
@ApiModelProperty("飞手id")
private Integer id;
@ApiModelProperty(value = "商务礼仪认证")
private Integer protocolAuth;
@ApiModelProperty(value = "电力巡检认证状态，0未认证，1通过，2未通过")
private Integer electricAuth;
@ApiModelProperty(value = "航空测绘认证状态，0未认证，1通过，2未通过", hidden = true)
@JsonIgnore
private Integer aviationAuth;
@ApiModelProperty(value = "应急保障认证状态，0未认证，1通过，2未通过", hidden = true)
@JsonIgnore
private Integer emergencyAuth;
@ApiModelProperty(value = "value = 监察巡检认证状态，0未认证，1通过，2未通过", hidden = true)
@JsonIgnore
private Integer superviseAuth;
@ApiModelProperty(value = "通用认证状态，0未认证，1通过，2未通过")
private Integer universalAuth;
@ApiModelProperty(value = "油气巡检认证状态，0未认证，1通过，2未通过")
private Integer oilGasAuth;
@ApiModelProperty(value = "演示认证状态，0未认证，1通过，2未通过")
private Integer demoAuth;
@ApiModelProperty(value = "航空测绘外业状态，0未认证，1通过，2未通过")
private Integer aviationOutAuth;
@ApiModelProperty(value = "航空测绘内业状态，0未认证，1通过，2未通过")
private Integer aviationInAuth;
@ApiModelProperty(value = "指挥车认证状态，0未认证，1通过，2未通过")
private Integer commandAuth;
@ApiModelProperty(value = "天目将软件认证状态，0未认证，1通过，2未通过")
private Integer tmjAuth;
}
src/main/java/com/mmc/oms/model/dto/GoodsInfoListDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 15:46
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.dto.GoodsInfoListDTO", description = "商品列表信息DTO")
public class GoodsInfoListDTO implements Serializable {
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "商品名称")
private String goodsName;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "状态 : 0:下架 1：上架")
private Integer status;
@ApiModelProperty(value = "商品主图")
private String imgUrl;
@ApiModelProperty(value = "一级分类名称")
private String goodsOneLevelTypeName;
@ApiModelProperty(value = "二级分类名称")
private String goodsTwoLevelTypeName;
@ApiModelProperty(value = "目录名字")
private String directoryName;
@ApiModelProperty(value = "目录id")
private Integer directoryId;
@ApiModelProperty(value = "是否有优惠券 0表示没有 有就返回数字")
private Integer isCoupons;
}
src/main/java/com/mmc/oms/model/dto/GoodsRcdDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:14
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.dto.GoodsRcdDTO", description = "推荐商品信息DTO")
public class GoodsRcdDTO implements Serializable {
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "推荐商品的id")
private Integer rcdGoodsId;
@ApiModelProperty(value = "推荐商品名称")
private String rcdGoodsName;
@ApiModelProperty(value = "推荐商品图片")
private String imgUrl;
@ApiModelProperty(value = "推荐商品描述")
private String rcdGoodsDescription;
}
src/main/java/com/mmc/oms/model/dto/MallUserDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:53
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.dto.MallUserDTO", description = "用户信息DTO")
public class MallUserDTO implements Serializable {
private static final long serialVersionUID = -2968237190830435082L;
@ApiModelProperty("id")
private Integer id;
@ApiModelProperty("uid")
private String uid;
@ApiModelProperty("个人认证名字")
private String userName;
@ApiModelProperty("联系电话")
private String phoneNum;
@ApiModelProperty("小程序openid")
private String openId;
@ApiModelProperty("微信unionid")
private String unionId;
@ApiModelProperty("微信昵称")
private String nickName;
@ApiModelProperty("头像")
private String headerImg;
@ApiModelProperty("经度")
private Double lon;
@ApiModelProperty("纬度")
private Double lat;
@ApiModelProperty("注册端口")
private String ports;
@ApiModelProperty("备注")
private String remark;
@ApiModelProperty(value = "用户来源：0自然流，1海报，2抖音，3公众号，4社群，5招投标，默认0")
private Integer source;
@ApiModelProperty("渠道等级状态")
private Integer channelAuthStatus;
@ApiModelProperty("渠道等级标签")
private Integer channelClass;
@ApiModelProperty("渠道等级名称")
private String tagName;
@ApiModelProperty("注册时间")
private Date createTime;
@ApiModelProperty("更新时间")
private Date updateTime;
@ApiModelProperty(value = "实名认证状态（0未通过，1通过）")
private Integer realAuthStatus;
@ApiModelProperty(value = "企业认证状态（0未通过，1通过）")
private Integer entAuthStatus;
@ApiModelProperty("企业名称")
private String entName;
@ApiModelProperty("法大大电子签章认证状态(0未通过，1通过)")
private Integer entVerifyStatus;
@ApiModelProperty("实名认证时间")
private Date realAuthTime;
@ApiModelProperty("企业认证时间")
private Date entAuthTime;
@ApiModelProperty("电子签章认证时间")
private Date entVerifyTime;
@ApiModelProperty(value = "上级推荐人id")
private Integer upReferralId;
@ApiModelProperty(value = "上级推荐人的uid(name)")
private String upReferralUidAndName;
@ApiModelProperty(value = "推荐伙伴数量")
private Integer lowerReferralCount;
@ApiModelProperty("相关运营id")
private Integer operateId;
@ApiModelProperty("相关运营Name")
private String operateName;
@ApiModelProperty("相关销售id")
private Integer saleId;
@ApiModelProperty("相关销售Name")
private String saleName;
@ApiModelProperty("小程序相关运营id")
private Integer mallOperator;
@ApiModelProperty("小程序相关运营名字")
private String mallOperatorName;
@ApiModelProperty("小程序相关运营uid")
private String mallOperatorUID;
@ApiModelProperty("小程序相关销售id")
private Integer mallSaleManager;
@ApiModelProperty("小程序相关销售uid")
private String mallSaleManagerUID;
@ApiModelProperty("小程序相关销售名字")
private String mallSaleManagerName;
@ApiModelProperty("上级渠道名称")
private String superiorChannelName;
@ApiModelProperty(value = "开户银行")
private String accountBank;
@ApiModelProperty(value = "开户姓名")
private String accountName;
@ApiModelProperty(value = "银行卡号")
private String bankCardNumber;
@ApiModelProperty(value = "支行")
private String branch;
}
src/main/java/com/mmc/oms/model/dto/OrderCouponDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:46
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.dto.OrderCouponDTO", description = "订单优惠券使用")
public class OrderCouponDTO implements Serializable {
private static final long serialVersionUID = 6681933441428005418L;
@ApiModelProperty("id")
private Integer id;
@ApiModelProperty("订单id")
private Long orderId;
@ApiModelProperty("用户优惠券id")
private Integer couponUserId;
@ApiModelProperty("优惠券类型")
private Integer couponType;
@ApiModelProperty("优惠券使用类型")
private Integer useType;
@ApiModelProperty("优惠券使用金额")
private BigDecimal useAmount;
@ApiModelProperty("使用时间")
private Date createTime;
@ApiModelProperty("优惠券简称")
private String couponName;
}
src/main/java/com/mmc/oms/model/dto/OrderTaskDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:01
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrderTaskDTO implements Serializable {
private static final long serialVersionUID = 6732943573766573605L;
@ApiModelProperty(value = "订单id")
private Integer id;
@ApiModelProperty(value = "主任务id")
private Integer parentId;
@ApiModelProperty(value = "用户id")
private Integer userAccountId;
@ApiModelProperty(value = "订单专属运营id")
private Integer userOperateId;
@ApiModelProperty(value = "用户订单uid")
private String uid;
@ApiModelProperty(value = "订单编号")
private String orderNo;//单号
@ApiModelProperty(value = "订单名称")
private String orderName;//名称
@ApiModelProperty(value = "账单金额")
private BigDecimal orderAmt;//账单金额
@ApiModelProperty(value = "订单现金金额")
private BigDecimal orderCashAmt;
@ApiModelProperty(value = "订单信用金额")
private BigDecimal orderCreditAmt;
@ApiModelProperty(value = "任务状态")
private Integer orderStatus;//任务状态
@ApiModelProperty(value = "评价状态")
private Integer evaluateStatus;//评价状态
private String lastMsg1;//消息
private String lastMag2;
@ApiModelProperty(value = "生成时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "备注")
private String basicInfo;//基本信息
@ApiModelProperty(value = "预计开始时间")
private String startTime;//开始时间
@ApiModelProperty(value = "预计结束时间")
private String endTime;//结束时间
@ApiModelProperty(value = "实际开始时间")
private String acStartTime;// 实际开始时间
@ApiModelProperty(value = "实际结束时间")
private String acEndTime;// 实际结束时间
@ApiModelProperty(value = "订单地址")
private String taskAddress;
private String image;
@ApiModelProperty(value = "服务id")
private Integer inspectionId;
@ApiModelProperty(value = "服务名称")
private String inspectionName;
@ApiModelProperty(value = "运营联系电话")
private String phoneNum;
@ApiModelProperty(value = "专属运营名称")
private String operateName;
@ApiModelProperty(value = "经度")
private BigDecimal lon;
@ApiModelProperty(value = "纬度")
private BigDecimal lat;
@ApiModelProperty(value = "用户名称")
private String userName;
@ApiModelProperty(value = "是否企业")
private Integer entUser;
@ApiModelProperty(value = "企业名称")
private String entName;
@ApiModelProperty(value = "是否实名")
private Integer realAuthStatus;
@ApiModelProperty(value = "昵称")
private String nickName;
@ApiModelProperty(value = "订单关闭原因")
private String shutReason;
@ApiModelProperty(value = "用户联系电话")
private String userPhoneNum;
@ApiModelProperty(value = "飞手Id")
private Integer flyerAccountId;
@ApiModelProperty(value = "平台工作人员设置的备注")
private String pfRemark;
@ApiModelProperty(value = "飞手端-推送-数据-0否-1是")
private Integer dummy;
@ApiModelProperty(value = "飞手UID")
private String flyerUid;
@ApiModelProperty(value = "飞手账号名")
private String flyerAccountName;
@ApiModelProperty(value = "抢单状态：0待接单,1抢单中")
private Integer applyStatus;
@ApiModelProperty(value = "预付款总金额")
private BigDecimal totalFreeze;
@ApiModelProperty(value = "结算总金额")
private BigDecimal totalPay;
@ApiModelProperty(value = "倒计时")
private Long countSconds;
@ApiModelProperty(value = "飞手基本信息")
private FlyerAccountDTO flyerAccount;
@ApiModelProperty(value = "飞手类型")
private Integer flyerType;
@ApiModelProperty(value = "飞手个数")
private Integer flyerNum;
@ApiModelProperty(value = "0:隐藏 1:显示")
private Integer display;
@ApiModelProperty(value = "飞手-结算-信息", hidden = true)
private TaskFlyerCostDTO taskFlyerCost;
@ApiModelProperty(value = "下期飞手入账时间")
private String nextFlyerIncomeDate;
@ApiModelProperty(value = "是否进行过催付款 0：未催 1：已催")
private Integer urge;
@ApiModelProperty(value = "订单类型")
private Integer orderType;
@ApiModelProperty(value = "确认需求备注")
private String cmdRemark;
@ApiModelProperty(value = "飞手可抢单开始时间")
private Date flyerStartTime;
@ApiModelProperty(value = "飞手可抢单结束时间")
private Date flyerEndTime;
@ApiModelProperty(value = "预估金额")
private BigDecimal estimatedAmount;
@ApiModelProperty(value = "申请id")
private Integer orderApplyId;
@ApiModelProperty(value = "用户下单附件预览效果")
private String userPreview;
@ApiModelProperty(value = "平台上传附件预览效果")
private String platformPreview;
@ApiModelProperty(value = "文案描述")
private String copywriting;
@ApiModelProperty(value = "子任务列表")
private List<OrderTaskDTO> children;
@ApiModelProperty(value = "子订单信息")
private List<OrderTaskSonDTO> son;
public void buildOperateUser(UserAccountDTO op) {
this.phoneNum = op.getPhoneNum();
this.operateName = op.getUserName();
this.userOperateId = op.getId();
}
public void buildWxUser(UserAccountDTO wx) {
this.userAccountId = wx.getId();
this.uid = wx.getUid();
this.nickName = wx.getNickName();
this.userName = wx.getUserName();
this.userPhoneNum = wx.getPhoneNum();
}
public FlyerOrderTaskDTO buildFlyerOrderTaskDTO(){
return FlyerOrderTaskDTO.builder().orderId(this.id).orderNo(this.orderNo).orderName(this.orderName).build();
}
}
src/main/java/com/mmc/oms/model/dto/OrderTaskSonDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* @Author small
* @Date 2023/5/24 15:01
* @Version 1.0
*/
@Data
//@ApiModel(value="OrderTaskSonDTO", description="云享飞订单-子任务表")
@AllArgsConstructor
@NoArgsConstructor
public class OrderTaskSonDTO implements Serializable {
private static final long serialVersionUID = 1L;
private Integer id;
@ApiModelProperty(value = "0为主任务")
private Integer parentId;
@ApiModelProperty(value = "客户ID")
private Integer userAccountId;
@ApiModelProperty(value = "运营人员ID（负责这个order的运营人员id")
private Integer userOperateId;
@ApiModelProperty(value = "订单编号")
private String orderNo;
@ApiModelProperty(value = "订单名称")
private String orderName;
@ApiModelProperty(value = "订单总金额")
private BigDecimal orderAmt;
@ApiModelProperty(value = "订单金额中的现金金额")
private BigDecimal cashAmt;
@ApiModelProperty(value = "订单金额中的信用金额")
private BigDecimal creditAmt;
@ApiModelProperty(value = "任务飞行地址")
private String taskAddress;
@ApiModelProperty(value = "基本信息")
private String basicInfo;
@ApiModelProperty(value = "服务开始时间")
private LocalDateTime startTime;
@ApiModelProperty(value = "服务结束时间")
private LocalDateTime endTime;
@ApiModelProperty(value = "实际服务开始时间")
private LocalDateTime acStartTime;
@ApiModelProperty(value = "实际服务结束时间")
private LocalDateTime acEndTime;
@ApiModelProperty(value = "0下单初始化(待分配运营）-> 100已分配运营（待需求确认）-> 200已经需求确认(待订单确认)-> 300已订单确认（待预支付）-> 400已预支付(调度中)-> 500飞手已接单(待抵达现场)-> 525飞手已抵达(待开始作业)-> 550已开始作业(作业中)-> 575飞手已完成作业(待平台确认作业完成)-> 600平台已确认作业完成(待验收结算)-> 700验收通过-> 900订单关闭")
private Integer orderStatus;
@ApiModelProperty(value = "评价状态：0未评价 1已评价")
private Integer evaluateStatus;
private LocalDateTime createTime;
private LocalDateTime updateTime;
@ApiModelProperty(value = "服务项ID")
private Integer inspectionId;
@ApiModelProperty(value = "服务名称")
private String inspectionName;
@ApiModelProperty(value = "最近一次操作信息")
private String lastMsg;
@ApiModelProperty(value = "任务地址经度")
private BigDecimal lon;
@ApiModelProperty(value = "任务地址纬度")
private BigDecimal lat;
@ApiModelProperty(value = "订单关闭原因")
private String shutReason;
@ApiModelProperty(value = "是否营销数据（假数据）：0:否 1:是")
private Boolean isDummy;
@ApiModelProperty(value = "平台备注")
private String pfRemark;
@ApiModelProperty(value = "飞手类型（0个人飞手 1飞手机构）")
private Integer flyerType;
@ApiModelProperty(value = "任务飞手人数")
private Integer flyerNum;
@ApiModelProperty(value = "0:隐藏 1:显示(隐藏后飞手端不显示，不参与抢单)")
private Integer display;
@ApiModelProperty(value = "飞手评价：0未评价 1已评价")
private Integer flyerEval;
@ApiModelProperty(value = "是否进行过催单 0：未通知 1：已通知")
private Integer isUrge;
@ApiModelProperty(value = "订单类型：0普通订单，1推荐订单，2加急单")
private Integer orderType;
@ApiModelProperty(value = "需求确认备注")
private String cmdRemark;
@ApiModelProperty(value = "飞手抢单开始时间")
private LocalDateTime flyerStartTime;
@ApiModelProperty(value = "飞手抢单结束时间")
private LocalDateTime flyerEndTime;
@ApiModelProperty(value = "推荐机构")
private Integer rcdCompanyId;
}
src/main/java/com/mmc/oms/model/dto/RepoAccountDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.Set;
/**
* @Author small
* @Date 2023/5/24 14:58
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.RepoAccountDTO", description = "云仓账号信息DTO")
public class RepoAccountDTO implements Serializable {
private static final long serialVersionUID = 1433562781546856233L;
@ApiModelProperty(value = "用户id")
private Integer id;
@ApiModelProperty(value = "用户uid")
private String uid;
@ApiModelProperty(value = "账号名称")
private String accountName;
@ApiModelProperty(value = "账号类型")
private Integer accountType;
@ApiModelProperty(value = "联系电话")
private String phoneNum;
@ApiModelProperty(value = "实名认证状态")
private Integer realAuthStatus;
@ApiModelProperty(value = "企业认证状态")
private Integer entAuthStatus;
@ApiModelProperty(value = "渠道认证状态")
private Integer channelAuthStatus;
@ApiModelProperty(value = "渠道等级")
private Integer channelClass;
@ApiModelProperty(value = "常驻城市")
private String resAddress;
@ApiModelProperty(value = "昵称")
private String nickName;
@ApiModelProperty(value = "头像url")
private String headerImg;
@ApiModelProperty(value = "经度")
private BigDecimal lon;
@ApiModelProperty(value = "纬度")
private BigDecimal lat;
@ApiModelProperty(value = "备注")
private String remark;
@ApiModelProperty(value = "删除状态，0未删除，1删除")
private Integer deleted;
@ApiModelProperty(value = "企业名称")
private String entName;
@ApiModelProperty(value = "用户名称")
private String userName;
@ApiModelProperty(value = "企业认证时间")
private Date entAuthTime;
@ApiModelProperty(value = "生成时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "现金余额")
private BigDecimal cashAmt;
private String unionId;
private String openId;
@ApiModelProperty(value = "多端用户，USER_PORT(云享飞)-FLYER_PORT(云飞手)-REPO_PORT(云仓)")
private Set<String> ports;
@ApiModelProperty(value = "用户推荐人数量")
private Integer rcdRepoTeamNum;
@ApiModelProperty(value = "推荐人Uid")
private String rcdUid;
@ApiModelProperty(value = "推荐人账户名称")
private String rcdAccountName;
@ApiModelProperty(value = "推荐人昵称")
private String rcdNickName;
@ApiModelProperty(value = "推荐人id")
private Integer rcdAccountId;
@ApiModelProperty(value = "是否销售")
private Integer sale;
@ApiModelProperty(value = "是否白名单")
private Integer white;
@ApiModelProperty(value = "用户来源：0自然流，1海报，2抖音，3公众号，4社群，5招投标，默认0")
private Integer source;
@ApiModelProperty(value = "推荐单位")
private String company;
@ApiModelProperty(value = "推荐单位ID", hidden = true)
private Integer rcdCompanyId;
}
src/main/java/com/mmc/oms/model/dto/RoleInfoDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 14:56
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "com.mmc.csf.model.dto.RoleInfoDTO", description = "角色信息DTO")
public class RoleInfoDTO implements Serializable {
private static final long serialVersionUID = -4791023169682602298L;
@ApiModelProperty(value = "角色ID")
private Integer id;
@ApiModelProperty(value = "角色编号")
private String roleNo;
@ApiModelProperty(value = "角色名称")
private String roleName;
@ApiModelProperty(value = "是否为管理角色:0否 1是")
private Integer admin;// 是否为管理角色
@ApiModelProperty(value = "是否为运营角色:0否 1是")
private Integer operate;
@ApiModelProperty(value = "是否为系统角色:0否 1是")
private Integer system;
@ApiModelProperty(value = "是否为PMC发货角色:0否 1是")
private Integer pmc;//PMC发货角色
@ApiModelProperty(value = "是否可用:0否 1是")
private Integer roleStatus;
@ApiModelProperty(value = "备注")
private String remark;
}
src/main/java/com/mmc/oms/model/dto/TaskFlyerCostDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:02
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.TaskFlyerCostDTO", description = "飞手工资DTO")
public class TaskFlyerCostDTO implements Serializable {
private static final long serialVersionUID = 4411028098471010440L;
@ApiModelProperty(value = "飞手工资id")
private Integer id;
@ApiModelProperty(value = "订单id")
private Integer orderTaskId;
@ApiModelProperty(value = "飞手日薪")
private BigDecimal flyerWag;
@ApiModelProperty(value = "飞手每日补贴")
private BigDecimal flyerSudy;
@ApiModelProperty(value = "每月工资结算日")
private Integer payDay;
@ApiModelProperty(value = "租房补贴")
private BigDecimal rentHouseSudy;
@ApiModelProperty(value = "交通补贴")
private BigDecimal trafficSudy;
@ApiModelProperty(value = "支付比例(例如0.95)")
private BigDecimal payPersent;
@ApiModelProperty(value = "设备信息")
private String deviceInfo;
@ApiModelProperty(value = "生成时间")
private Date createTime;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "任务编号")
private String orderNo;
@ApiModelProperty(value = "任务名称")
private String orderName;
@ApiModelProperty(value = "飞手数量")
private Integer flyerNum;
@ApiModelProperty(value = "服务类型")
private String inspectionName;
@ApiModelProperty(value = "飞手类型（0个人飞手 1飞手机构）")
private Integer flyerType;
@ApiModelProperty(value = "任务工资信息列表")
private List<WagTermDetailDTO> details;
@ApiModelProperty(value = "任务开始日")
private Date startTime;
@ApiModelProperty(value = "任务结束日")
private Date endTime;
@ApiModelProperty(value = "高温补贴")
private BigDecimal hotSudy;
@ApiModelProperty(value = "预估金额")
private BigDecimal estimateWag;
@ApiModelProperty(value = "补助标签")
private String sudyTag;
public void defaultValue() {
if (this.flyerWag == null) {
this.flyerWag = BigDecimal.ZERO;
}
if (this.flyerSudy == null) {
this.flyerSudy = BigDecimal.ZERO;
}
if (this.rentHouseSudy == null) {
this.rentHouseSudy = BigDecimal.ZERO;
}
if (this.trafficSudy == null) {
this.trafficSudy = BigDecimal.ZERO;
}
if (this.payPersent == null) {
this.payPersent = BigDecimal.ZERO;
}
if(this.hotSudy == null) {
this.hotSudy = BigDecimal.ZERO;
}
}
}
src/main/java/com/mmc/oms/model/dto/TypeGoodsInfoDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:20
* @Version 1.0
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.dto.TypeGoodsInfoDTO", description = "分类下关联的商品")
public class TypeGoodsInfoDTO implements Serializable {
private static final long serialVersionUID = 7151146563536604554L;
@ApiModelProperty(value = "商品id")
private Integer goodsId;
@ApiModelProperty(value = "商品名称")
private String goodsName;
@ApiModelProperty(value = "商品主图")
private String goodsImg;
@ApiModelProperty(value = "商品上下架状态")
private Integer shelfStatus;
@ApiModelProperty(value = "商品安全编码是否显示：0否 1是")
private Integer showCode;
}
src/main/java/com/mmc/oms/model/dto/UserAccountDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:56
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "com.mmc.csf.model.dto.UserAccountDTO", description = "用户信息DTO")
public class UserAccountDTO implements Serializable {
private static final long serialVersionUID = -3760693134872196985L;
@ApiModelProperty(value = "用户ID")
private Integer id;
@ApiModelProperty(value = "UID")
private String uid;
@ApiModelProperty(value = "账号")
private String accountNo;
@ApiModelProperty(value = "密码")
private String passWord;
@ApiModelProperty(value = "昵称")
private String nickName;
@ApiModelProperty(value = "姓名")
private String userName;
@ApiModelProperty(value = "身份证号码")
private String idNumber;
@ApiModelProperty(value = "电话号码")
private String phoneNum;
@ApiModelProperty(value = "性别：0未知 1男 2女 ")
private Integer userSex;
@ApiModelProperty(value = "常住地址")
private String resAddres;
private Integer realAuthStatus;
@ApiModelProperty(value = "常住地址-经度")
private String longitude;
@ApiModelProperty(value = "常住地址-纬度")
private String latitude;
@ApiModelProperty(value = "是否企业用户：0否 1是")
private Integer entUser;
@ApiModelProperty(value = "是否渠道用户：0否 1是")
private Integer channelUser;
@ApiModelProperty(value = "备注")
private String remark;
@ApiModelProperty(value = "账号类型：0神行太保平台账号 ; 100云享飞-客户端; 101云享飞-飞手端; 102云享飞-云仓端")
private Integer accountType;
@ApiModelProperty(value = "账号状态：0禁用 1可用")
private Integer accountStatus;
@ApiModelProperty(value = "角色信息")
private RoleInfoDTO roleInfo;
@ApiModelProperty(value = "更新时间")
private Date updateTime;
@ApiModelProperty(value = "身份证正面照")
private String frontIdImg;
@ApiModelProperty(value = "身份证反面照")
private String backIdImg;
@ApiModelProperty(value = "邮箱")
private String email;
@ApiModelProperty(value = "单位信息")
private CompanySimpleDTO companyInfo;
private Integer rcdCompanyId;
@ApiModelProperty(value = "渠道等级")
private String channelLevel;
@ApiModelProperty(value = "法大大企业认证状态")
private Integer entVerifyStatus;
public UserAccountDTO(Integer id, String uid, String nickName) {
this.id = id;
this.uid = uid;
this.nickName = nickName;
}
}
src/main/java/com/mmc/oms/model/dto/WagTermDetailDTO.java 0 → 100644
package com.mmc.oms.model.dto;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 15:03
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.WagTermDetailDTO", description = "任务工资信息DTO")
public class WagTermDetailDTO implements Serializable {
private static final long serialVersionUID = 6088946395006027466L;
@ApiModelProperty(value = "ID")
private Integer id;
@ApiModelProperty(value = "工资日期")
private Date costDate;
@ApiModelProperty(value = "工资(元/日)")
private BigDecimal wagPrice;
@ApiModelProperty(value = "补贴(元/日)")
private BigDecimal sudyPrice;
@ApiModelProperty(value = "出差租房补贴(元/日)")
private BigDecimal rentHousePrice;
@ApiModelProperty(value = "出差交通补贴(元/日)")
private BigDecimal trafficPrice;
@ApiModelProperty(value = "高温补贴(元/日)")
private BigDecimal hotPrice;
@ApiModelProperty(value = "飞手人数")
private Integer flyerNum;
@ApiModelProperty(value = "支付比例")
private BigDecimal payPersent;
@ApiModelProperty(value = "应结工资")
private BigDecimal shouldPay;
@ApiModelProperty(value = "补贴合计-单价（不计算人数）")
private BigDecimal daySudyUnit;
public void defaultValue() {
if (this.wagPrice == null) {
this.wagPrice = BigDecimal.ZERO;
}
if (this.sudyPrice == null) {
this.sudyPrice = BigDecimal.ZERO;
}
if (this.rentHousePrice == null) {
this.rentHousePrice = BigDecimal.ZERO;
}
if (this.trafficPrice == null) {
this.trafficPrice = BigDecimal.ZERO;
}
if (this.wagPrice == null) {
this.wagPrice = BigDecimal.ZERO;
}
if (this.payPersent == null) {
this.payPersent = BigDecimal.ZERO;
}
if (this.flyerNum == null) {
this.flyerNum = 0;
}
}
}
src/main/java/com/mmc/oms/model/qo/BaseInfoQO.java 0 → 100644
package com.mmc.oms.model.qo;
import com.mmc.oms.common.Freeze;
import com.mmc.oms.common.Page;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
/**
* @Author small
* @Date 2023/5/24 14:02
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class BaseInfoQO {
@ApiModelProperty(value = "开始时间")
private String startTime;
@ApiModelProperty(value = "结束时间")
private String endTime;
@ApiModelProperty(value = "页码")
@NotNull(message = "页码不能为空", groups = { Page.class, Freeze.class })
@Min(value = 1, groups = Page.class,message = "pageNo不能少于1")
private Integer pageNo;
@ApiModelProperty(value = "每页显示数")
@NotNull(message = "每页显示数不能为空", groups = { Page.class, Freeze.class })
@Min(value = 1, groups = Page.class,message = "pageSize不能少于1")
private Integer pageSize;
/**
* 初始化起始查询行并返回当前页
*/
public Integer buildCurrentPage() {
Integer pageNo = this.pageNo;
this.pageNo = (pageNo - 1) * pageSize;
return pageNo;
}
}
src/main/java/com/mmc/oms/model/qo/CouponInfoQO.java 0 → 100644
package com.mmc.oms.model.qo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Length;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 14:01
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "CouponQO对象", description = "Coupon查询QO")
public class CouponInfoQO extends BaseInfoQO implements Serializable {
@ApiModelProperty(value = "优惠券状态 是否可领取 false否 true：是")
private Boolean state;
@ApiModelProperty(value = "优惠券id")
private String couponId;
@ApiModelProperty(value = "优惠券使用类型 1vip,2品牌券",required = true)
private Integer useType;
@ApiModelProperty(value = "优惠券名称")
@Length(max = 64, message = "优惠券名称长度不能超过64个字符")
private String couponName;
}
src/main/java/com/mmc/oms/model/qo/CouponUserInfoQO.java 0 → 100644
package com.mmc.oms.model.qo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 14:10
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "CouponUserQO对象", description = "CouponUser查询QO")
public class CouponUserInfoQO extends BaseInfoQO implements Serializable {
@ApiModelProperty(value = "用户id")
private String uid;
@ApiModelProperty(value = "用户手机号")
private String userPhone;
@ApiModelProperty(value = "优惠券id")
private Integer couponId;
@ApiModelProperty(value = "订单编号")
private String orderNumber;
@ApiModelProperty(value = "获取方式:用户领取receive, 系统发放send, 赠送presented, 获赠acquire,积分兑换exchange")
private String gainType;
@ApiModelProperty(value = "状态（0：未使用，1：已使用, 2:已失效，3:已转赠）")
private Integer state;
@ApiModelProperty(value = "使用时间 yyyy-MM-dd")
private String useTime;
@ApiModelProperty(value = "领取时间 yyyy-MM-dd")
private String createTime;
}
src/main/java/com/mmc/oms/model/qo/ProductCouponQO.java 0 → 100644
package com.mmc.oms.model.qo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 14:10
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "ProductCouponQO对象",description = "ProductCouponQO查询Qo")
public class ProductCouponQO extends BaseInfoQO implements Serializable {
@ApiModelProperty(value = "商品id")
@NotNull(message = "参数[goodsInfoId]不能为空")
private Integer goodsInfoId;
}
src/main/java/com/mmc/oms/model/vo/AddGoodsVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:31
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class AddGoodsVO implements Serializable {
private static final long serialVersionUID = -7111517437845894938L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "加购商品id")
private Integer addGoodsId;
@ApiModelProperty(value = "分类id")
private Integer goodsTypeId;
}
src/main/java/com/mmc/oms/model/vo/AddOnGoodsVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:31
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AddOnGoodsVO implements Serializable {
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "项目名称")
private String projectName;
@ApiModelProperty(value = "加购商品id集合")
private List<AddGoodsVO> addGoods;
}
src/main/java/com/mmc/oms/model/vo/AppletMsgVO.java 0 → 100644
package com.mmc.oms.model.vo;
import com.alibaba.fastjson.JSONObject;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 16:09
* @Version 1.0
*/
@Builder
@Data
@NoArgsConstructor
@AllArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.vo.AppletMsgVO", description = "小程序订阅消息VO")
public class AppletMsgVO implements Serializable {
private static final long serialVersionUID = 2124104608303700492L;
@ApiModelProperty(value = "openid")
@NotBlank
private String touser;
@ApiModelProperty(value = "模板ID")
@NotBlank
private String template_id;
@ApiModelProperty(value = "点击模板卡片后的跳转页面，仅限本小程序内的页面。支持带参数,（示例index?foo=bar）。该字段不填则模板无跳转。")
private String page;
@ApiModelProperty(value = "模板内容")
private JSONObject data;
@ApiModelProperty(value = "跳转小程序类型：developer为开发版；trial为体验版；formal为正式版；默认为正式版")
private String miniprogram_state;
@ApiModelProperty(value = "默认为zh_CN")
private String lang;
}
src/main/java/com/mmc/oms/model/vo/CategoryParamAndValueVO.java 0 → 100644
package com.mmc.oms.model.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @Author small
* @Date 2023/5/24 15:25
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CategoryParamAndValueVO {
private String param;
private String value;
}
src/main/java/com/mmc/oms/model/vo/CategoryParamValueVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 16:05
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class CategoryParamValueVO implements Serializable {
private static final long serialVersionUID = 556877053092400817L;
@ApiModelProperty(value = "参数id")
private Integer id;
@ApiModelProperty(value = "参数值")
private String paramValue;
@ApiModelProperty(value = "参数值Id")
private Integer categoryValueId;
}
src/main/java/com/mmc/oms/model/vo/CouponInfoActivityVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.Range;
import javax.validation.constraints.DecimalMax;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 13:34
* @Version 1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
//@ApiModel(value="CouponInfoActivityVO对象", description="裂变优惠券表添加/修改VO")
public class CouponInfoActivityVO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "优惠券名称", required = true)
@NotBlank(message = "请填写优惠券名称")
@Length(max = 64, message = "优惠券名称长度不能超过64个字符")
private String couponName;
@ApiModelProperty(value = "分享者-优惠券使用类型 1vip,2品牌券",required = true)
@Range(min = 1, max = 2, message = "请选择优惠券使用类型")
private Integer useType;
@ApiModelProperty(value = "分享者-所属 品牌范围id 例：5,9... ", required = true)
private String primaryKey;
@ApiModelProperty(value = "分享者-可使用时间范围 开始时间 yyyy-MM-dd HH:mm:ss",required = true)
private Date useStartTime;
@ApiModelProperty(value = "分享者-可使用时间范围 结束时间 yyyy-MM-dd HH:mm:ss",required = true)
private Date useEndTime;
@ApiModelProperty(value = "分享者-兑换的优惠券面值", required = true)
@NotNull(message = "请填写优惠券兑换的优惠券面值")
@DecimalMax(value = "99999.99", message = "优惠券面值不能大于99999.99")
private BigDecimal couponMoney;
@ApiModelProperty(value = "分享者-最低消费 0为无门槛",required = true)
private BigDecimal minPrice;
@ApiModelProperty(value = "分享者-优惠券类型 1打折卷, 2减免券 3无门槛",required = true)
@Range(min = 1, max = 3, message = "请选择优惠券类型")
private Integer couponType;
@ApiModelProperty(value = "分享者-优惠券折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "分享者-是否多次核销 0单次核销 1多次核销",required = true)
private Boolean verificationType;
@ApiModelProperty(value = "分享者-发放总数",required = true)
private Integer couponTotal;
@ApiModelProperty(value = "分享者-每人限制领取张数",required = true)
private Integer restrictedAccess;
@ApiModelProperty(value = "被分享用户标签")
private Integer userTag;
@ApiModelProperty(value = "分享者-分享人数")
private Integer peopleNumber ;
@ApiModelProperty(value = "分享者-最多优惠")
private BigDecimal preferentialLimit;
@ApiModelProperty(value = "被分享者-优惠券使用类型 1vip,2品牌券",required = true)
@Range(min = 1, max = 2, message = "请选择优惠券使用类型")
private Integer beSharedUseType;
@ApiModelProperty(value = "被分享者-所属 品牌范围id 例：5,9... ", required = true)
private String beSharedPrimaryKey;
@ApiModelProperty(value = "被分享者-兑换的优惠券面值", required = true)
@NotNull(message = "请填写优惠券兑换的优惠券面值")
@DecimalMax(value = "99999.99", message = "优惠券面值不能大于99999.99")
private BigDecimal beSharedCouponMoney;
@ApiModelProperty(value = "被分享者-最低消费 0为无门槛",required = true)
private BigDecimal beSharedMinPrice;
@ApiModelProperty(value = "被分享者-优惠券类型 1打折卷, 2减免券 3无门槛",required = true)
@Range(min = 1, max = 3, message = "请选择优惠券类型")
private Integer beSharedCouponType;
@ApiModelProperty(value = "分享者-发放总数",required = true)
private Integer beSharedCouponTotal;
@ApiModelProperty(value = "被分享者-优惠券折扣")
private BigDecimal beSharedCouponDiscount;
@ApiModelProperty(value = "被分享者-是否多次核销 0单次核销 1多次核销",required = true)
private Boolean beSharedVerificationType;
@ApiModelProperty(value = "被分享者-最多优惠")
private BigDecimal beSharedPreferentialLimit;
}
src/main/java/com/mmc/oms/model/vo/CouponInfoVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.Range;
import javax.validation.constraints.DecimalMax;
import javax.validation.constraints.Max;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:00
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@EqualsAndHashCode(callSuper = false)
//@Accessors(chain = true)
//@ApiModel(value="CouponVO对象", description="优惠券表添加/修改VO")
public class CouponInfoVO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "优惠券名称", required = true)
@NotBlank(message = "请填写优惠券名称")
@Length(max = 64, message = "优惠券名称长度不能超过64个字符")
private String couponName;
@ApiModelProperty(value = "兑换的优惠券面值", required = true)
@NotNull(message = "请填写优惠券兑换的优惠券面值")
@DecimalMax(value = "99999.99", message = "优惠券面值不能大于99999.99")
private BigDecimal couponMoney;
@ApiModelProperty(value = "优惠券折扣")
private BigDecimal couponDiscount;
@ApiModelProperty(value = "是否限量, false否， true是", required = true)
@NotNull(message = "请设置是否限量")
private Boolean isLimited;
@ApiModelProperty(value = "发放总数")
private Integer couponTotal;
@ApiModelProperty(value = "优惠券类型 1打折卷, 2减免券 3无门槛",required = true)
@Range(min = 1, max = 3, message = "请选择优惠券类型")
private Integer couponType;
@ApiModelProperty(value = "优惠券使用类型 1vip,2品牌券",required = true)
@Range(min = 1, max = 2, message = "请选择优惠券使用类型")
private Integer useType;
@ApiModelProperty(value = "所属 品牌范围id 例：5,9... ", required = true)
private String primaryKey;
@ApiModelProperty(value = "最低消费",required = true)
private BigDecimal minPrice;
@ApiModelProperty(value = "有效期使用时间方式：0 固定使用时间, 1领取当日起 2领取次日起", required = true)
@NotNull(message = "请选择领取是否限时")
private Integer isFixedTime;
@ApiModelProperty(value = "可使用时间范围 开始时间 yyyy-MM-dd HH:mm:ss")
private Date useStartTime;
@ApiModelProperty(value = "可使用时间范围 结束时间 yyyy-MM-dd HH:mm:ss")
private Date useEndTime;
@ApiModelProperty(value = "可使用时间 天数")
@Max(value = 999, message = "天数不能超过999天")
private Integer couponDay;
@ApiModelProperty(value = "优惠券类型 1 手动领取 2 系统发放 3 批量导入用户",required = true)
@Range(min = 1, max = 3, message = "请选择优惠券领取方式")
private Integer getType;
@ApiModelProperty(value = "用户标签")
private Integer userTag;
@ApiModelProperty(value = "每人限制领取张数")
private Integer restrictedAccess;
@ApiModelProperty(value = "最多优惠")
private BigDecimal preferentialLimit;
@ApiModelProperty(value = "是否单次核销 false单次核销 true多次核销",required = true)
private Boolean verificationType;
@ApiModelProperty(value = "是否单次核销 0单次核销 1多次核销")
private String fileUrl;
}
src/main/java/com/mmc/oms/model/vo/CouponUserExchangeVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @Author small
* @Date 2023/5/24 14:50
* @Version 1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
//@ApiModel(value = "CouponUserVO对象", description = "优惠券兑换表VO")
public class CouponUserExchangeVO implements Serializable {
private static final long serialVersionUID = 1L;
@ApiModelProperty(value = "用户id", required = true)
private Integer uid;
@ApiModelProperty(value = "用户Uid", required = true)
private String uuid;
@ApiModelProperty(value = "用户手机号", required = true)
private String userPhone;
@ApiModelProperty(value = "优惠券名称", required = true)
private String couponName;
@ApiModelProperty(value = "优惠券面值", required = true)
private BigDecimal couponMoney;
@ApiModelProperty(value = "兑换比例", required = true)
private String conversionRatio;
@ApiModelProperty(value = "兑换积分数值")
private Long score;
@ApiModelProperty(value = "pid")
public Integer pid;
@ApiModelProperty(value = "唯一id")
public String msgId;
}
src/main/java/com/mmc/oms/model/vo/CouponUserVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Range;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 14:47
* @Version 1.0
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
//@ApiModel(value="CouponUserVO对象", description="优惠券记录表修改VO")
public class CouponUserVO implements Serializable {
private static final long serialVersionUID=1L;
@ApiModelProperty(value = "用户优惠券id",required = true)
private Integer id;
@ApiModelProperty(value = "订单id",required = true)
private Long cid;
@ApiModelProperty(value = "订单编码",required = true)
private String orderNo;
@ApiModelProperty(value = "状态（0：未使用，1：已使用, 2:已失效，3:已转赠 4:使用中）",required = true)
@Range(min = 1, max = 4, message = "请选择优惠券类型")
private Integer status;
@ApiModelProperty(value = "剩余余额")
private BigDecimal remainingBalance;
/**
* 开始
* 转换使用
*/
@ApiModelProperty(value = "使用金额")
private BigDecimal useAmount;
@ApiModelProperty("优惠券类型")
private Integer couponType;
@ApiModelProperty("优惠券使用类型")
private Integer useType;
/**
* 结束
*/
/**
* 使用时间
*/
private Date orderUsageTime;
}
src/main/java/com/mmc/oms/model/vo/GoodsAddVO.java 0 → 100644
package com.mmc.oms.model.vo;
import com.mmc.oms.common.Create;
import com.mmc.oms.common.Update;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:32
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class GoodsAddVO implements Serializable {
private static final long serialVersionUID = 7041502536618388167L;
@ApiModelProperty(value = "id")
@NotNull(message = "修改时id不能为空", groups = {Update.class})
private Integer id;
@ApiModelProperty(value = "商品图片")
@NotEmpty(message = "主图不能为空", groups = {Update.class, Create.class})
private List<GoodsImgVO> images;
@ApiModelProperty(value = "商品视频")
private String goodsVideo;
@ApiModelProperty(value = "商品名称")
@NotNull(message = "商品名称不能为空", groups = {Update.class, Create.class})
private String goodsName;
@ApiModelProperty(value = "商品详情")
private GoodsDetailVO goodsDetailVO;
@ApiModelProperty(value = "所属目录")
@NotNull(message = "所属目录不能为空", groups = {Update.class, Create.class})
private Integer sortTypeId;
@ApiModelProperty(value = "一级分类id")
@NotNull(message = "分类不能为空", groups = {Update.class, Create.class})
private Integer masterTypeId;
@ApiModelProperty(value = "二级分类id")
private Integer slaveTypeId;
@ApiModelProperty(value = "商品标签")
private String tag;
@ApiModelProperty(value = "商品状态 0:下架 1:上架")
private Integer shelfStatus;
@ApiModelProperty(value = "规格信息")
private List<GoodsSpecVO> GoodsSpecVO;
@ApiModelProperty(value = "其他服务: 1:免费配送，2：专业飞手培训2日， 3：半年保修， 4：一年保修 ")
private List<Integer> otherService;
@ApiModelProperty(value = "云享飞服务id")
private Integer shareFlyServiceId;
@ApiModelProperty(value = "云仓配件id")
private Integer repoId;
@ApiModelProperty(value = "常见问题")
private List<GoodsQaVO> question;
}
src/main/java/com/mmc/oms/model/vo/GoodsConfigExportVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:30
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class GoodsConfigExportVO implements Serializable {
private static final long serialVersionUID = 7361972657864829679L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "商品清单")
private String inventory;
@ApiModelProperty(value = "功能配置")
private String functionConfig;
}
src/main/java/com/mmc/oms/model/vo/GoodsDetailVO.java 0 → 100644
package com.mmc.oms.model.vo;
import com.mmc.oms.common.Create;
import com.mmc.oms.common.Update;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.Size;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:27
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.vo.GoodsDetailVO", description = "商品详情")
public class GoodsDetailVO implements Serializable {
private static final long serialVersionUID = -3842207843504795301L;
@ApiModelProperty(value = "商品描述 ：70字内")
@Size(max = 250, message = "商品描述不能超过250个字符", groups = {Create.class, Update.class})
private String goodsDesc;
@ApiModelProperty(value = "产品介绍")
private String productDesc;
@ApiModelProperty(value = "商品备注：100字以内")
@Size(max = 100, message = "商品备注不能超过100个字符", groups = {Create.class, Update.class})
private String remark;
}
src/main/java/com/mmc/oms/model/vo/GoodsImgVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:27
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.vo.GoodsImgVO", description = "新增/修改参数类")
public class GoodsImgVO implements Serializable {
private static final long serialVersionUID = 7742617679026160607L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "商品图片地址")
private String imgUrl;
@ApiModelProperty(value = "商品图片类型 0:主图 1：副图")
private Integer imgType;
}
src/main/java/com/mmc/oms/model/vo/GoodsInfoVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:26
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class GoodsInfoVO implements Serializable {
private static final long serialVersionUID = -1013903595793128096L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "商品视频")
private String goodsVideo;
@ApiModelProperty(value = "商品属性 0：自营 1：生态")
private Integer goodsAttr;
@ApiModelProperty(value = "生态标签")
private String ecoLabel;
@ApiModelProperty(value = "商品名称")
private String goodsName;
@ApiModelProperty(value = "商品主类型ID")
private Integer masterTypeId;
@ApiModelProperty(value = "商品子类型ID")
private Integer slaveTypeId;
@ApiModelProperty(value = "类目id")
private Integer goodsCategoryId;
@ApiModelProperty(value = "云享飞服务id")
private Integer shareFlyServiceId;
@ApiModelProperty(value = "云仓配件id")
private Integer repoId;
@ApiModelProperty(value = "参数值对象")
private List<CategoryParamValueVO> categoryParamValueList;
}
src/main/java/com/mmc/oms/model/vo/GoodsQaVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:30
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.vo.GoodsQaVO", description = "新增/修改参数类")
public class GoodsQaVO implements Serializable {
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "问题")
private String question;
@ApiModelProperty(value = "回答")
private String answer;
}
src/main/java/com/mmc/oms/model/vo/GoodsSkuVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:28
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class GoodsSkuVO implements Serializable {
private static final long serialVersionUID = 2615485745217499939L;
@ApiModelProperty(value = "规格值id")
private Long id;
@ApiModelProperty(value = "规格值名称")
private String specValueName;
@ApiModelProperty(value = "图片")
private String picture;
}
src/main/java/com/mmc/oms/model/vo/GoodsSpecVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:33
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class GoodsSpecVO implements Serializable {
private static final long serialVersionUID = -8681372139970849591L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "规格名称")
private String goodsSpecName;
@ApiModelProperty(value = "产品类型")
private Integer goodsTypeId;
@ApiModelProperty(value = "产品:自定义时此字段可不用填写")
private Integer skuId;
@ApiModelProperty(value = "规格来源 0:获取 1：自定义")
private Integer flag;
@ApiModelProperty(value = "产品名称（自定义的时候才需要传值）")
private String productName;
@ApiModelProperty(value = "选项来源")
private List<MallProductSpecVO> specIds;
@ApiModelProperty(value = "选择方式")
private Integer chooseType;
@ApiModelProperty(value = "规格单位")
private Integer skuUnitId;
@ApiModelProperty(value = "是否必选")
private Integer must;
@ApiModelProperty(value = "自定义的信息填充")
private List<ProductSpecVO> customizeInfo;
@ApiModelProperty(value = "删除的自定义规格id")
private List<Integer> delProductSpecId;
}
src/main/java/com/mmc/oms/model/vo/MallGoodsAddVO.java 0 → 100644
package com.mmc.oms.model.vo;
import com.mmc.oms.common.Create;
import com.mmc.oms.common.Update;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotEmpty;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:26
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.vo.MallGoodsAddVO", description = "机城商品新增VO")
public class MallGoodsAddVO implements Serializable {
private static final long serialVersionUID = -6942710361131878887L;
@ApiModelProperty(value = "商品类型 0:硬件产品 1：方案套餐")
private Integer goodsType;
@ApiModelProperty(value = "spuId")
private Long spuId;
@ApiModelProperty(value = "商品基本信息")
private GoodsInfoVO goodsInfoVO;
@ApiModelProperty(value = "商品图片")
@NotEmpty(message = "商品图片不能为空", groups = {Create.class, Update.class})
private List<GoodsImgVO> imgList;
@ApiModelProperty(value = "商品详情VO")
private GoodsDetailVO goodsDetailVO;
@ApiModelProperty(value = "硬件产品对象")
private List<ProductSkuVO> productSkuVO;
@ApiModelProperty(value = "方案套餐")
private List<PlanPackageVO> planPackageVO;
@ApiModelProperty(value = "其他服务: 1:免费配送，2：专业飞手培训2日， 3：半年保修， 4：一年保修 ")
private List<Integer> otherService;
@ApiModelProperty(value = "推荐配件")
private List<Integer> rcdId;
@ApiModelProperty(value = "常见问题")
private List<GoodsQaVO> question;
@ApiModelProperty(value = "清单及配置信息")
private GoodsConfigExportVO goodsConfigExport;
@ApiModelProperty(value ="规格组合集合")
private List<SpuValuesVO> spu;
@ApiModelProperty(value = "加购商品")
private List<AddOnGoodsVO> addOnGoods;
}
src/main/java/com/mmc/oms/model/vo/MallProductSpecVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:33
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Accessors
public class MallProductSpecVO implements Serializable {
private static final long serialVersionUID = -2681122778843398310L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "产品或行业规格id")
private Integer mallSpecId;
}
src/main/java/com/mmc/oms/model/vo/PlanPackageVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:29
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class PlanPackageVO implements Serializable {
private static final long serialVersionUID = -7095827435029350011L;
@ApiModelProperty(value = "id")
private Long id;
@ApiModelProperty(value = "规格值名称")
private String specValueName;
@ApiModelProperty(value = "规格描述")
private String specDesc;
@ApiModelProperty(value = "产品集合")
private List<ProductVO> productId;
}
src/main/java/com/mmc/oms/model/vo/ProductSkuVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:28
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ProductSkuVO implements Serializable {
private static final long serialVersionUID = -3548166687985505798L;
@ApiModelProperty(value = "id")
private Long id;
@ApiModelProperty(value = "规格名称")
private String specName;
@ApiModelProperty(value = "硬件产品内容对象")
private List<GoodsSkuVO> goodsSkuVO;
}
src/main/java/com/mmc/oms/model/vo/ProductSpecCPQVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 15:34
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ProductSpecCPQVO implements Serializable {
private static final long serialVersionUID = 6055658459871113781L;
@ApiModelProperty(value = "产品规格id")
private Integer productSpecId;
@ApiModelProperty(value = "规格价格配置VO")
private List<SpecPriceVO> specPrice;
}
src/main/java/com/mmc/oms/model/vo/ProductSpecVO.java 0 → 100644
package com.mmc.oms.model.vo;
import com.mmc.oms.common.Create;
import com.mmc.oms.common.Update;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:33
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class ProductSpecVO implements Serializable {
private static final long serialVersionUID = -2681122778843398310L;
@ApiModelProperty(value = "id")
@NotNull(message = "修改时id不能为空", groups = {Update.class})
private Integer id;
@ApiModelProperty(value = "productSkuId")
@NotNull(message = "修改时productSkuId不能为空", groups = {Create.class})
private Integer productSkuId;
@NotNull(message = "规格名称不能为空", groups = {Update.class, Create.class})
@ApiModelProperty(value = "规格名称")
private String specName;
@NotNull(message = "规格图片不能为空", groups = {Update.class, Create.class})
@ApiModelProperty(value = "规格图片")
private String specImage;
@NotNull(message = "料号不能为空", groups = {Update.class, Create.class})
@ApiModelProperty(value = "料号")
private String partNo;
@ApiModelProperty(value = "版本描述")
private String versionDesc;
@ApiModelProperty(value = "价格配置信息")
private ProductSpecCPQVO productSpecCPQVO;
}
src/main/java/com/mmc/oms/model/vo/ProductVO.java 0 → 100644
package com.mmc.oms.model.vo;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 15:29
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ProductVO implements Serializable {
private static final long serialVersionUID = 8702074195817129743L;
private Integer id;
private Integer productId;
private Long mallSkuId;
}
src/main/java/com/mmc/oms/model/vo/SpecPriceVO.java 0 → 100644
package com.mmc.oms.model.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @Author small
* @Date 2023/5/24 15:34
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SpecPriceVO implements Serializable {
private static final long serialVersionUID = -8976672168410262190L;
private Integer id;
private Integer tagInfoId;
private BigDecimal price;
}
src/main/java/com/mmc/oms/model/vo/SpuValuesVO.java 0 → 100644
package com.mmc.oms.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.LinkedHashMap;
/**
* @Author small
* @Date 2023/5/24 15:31
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.mall.vo.SpuValuesVO", description = "Sku预览图DTO")
public class SpuValuesVO implements Serializable {
@ApiModelProperty(value = "规格值组合")
private LinkedHashMap<String, String> spu;
@ApiModelProperty(value = "库存")
private Integer stock;
}
src/main/java/com/mmc/oms/model/vo/WxSendMsgVO.java 0 → 100644
package com.mmc.oms.model.vo;
import com.alibaba.fastjson.JSONObject;
import com.mmc.oms.common.MsgData;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.util.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 16:13
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.vo.WxSendMsgVO", description = "微信服务通知VO")
public class WxSendMsgVO implements Serializable {
private static final long serialVersionUID = -2308646143286881148L;
@ApiModelProperty(value = "用户id-仅适用云享飞客户端")
private Integer userAccountId;
@ApiModelProperty(value = "公众号的openId")
private String openId;
@ApiModelProperty(value = "unionId-全局通用")
private String unionId;
@ApiModelProperty(value = "模板id")
@NotNull(message = "模板id不能为空")
private String templemteId;
@ApiModelProperty(value = "网页跳转连接")
private String url;
@ApiModelProperty(value = "小程序APPID")
private String wxAppltAppId;
@ApiModelProperty(value = "小程序跳转连接")
private String appletPath;
@ApiModelProperty(value = "标题")
private MsgData title;
@ApiModelProperty(value = "消息数组")
private List<MsgData> data;
@ApiModelProperty(value = "消息备注")
private MsgData remark;
public String buildMsgJson() {
JSONObject obj = new JSONObject();
obj.put("touser", this.openId);
obj.put("template_id", this.templemteId);
if (!StringUtils.isBlank(this.url)) {
obj.put("url", this.url);
}
if (!StringUtils.isBlank(this.wxAppltAppId) && !StringUtils.isBlank(this.appletPath)) {
JSONObject mini = new JSONObject();
mini.put("appid", this.wxAppltAppId);
mini.put("pagepath", this.appletPath);
obj.put("miniprogram", mini);
}
JSONObject jd = new JSONObject();
jd.put("first", this.convertMsg(title));
if (!CollectionUtils.isEmpty(this.data)) {
for (int i = 0; i < data.size(); i++) {
String key = "keyword" + (i + 1);
jd.put(key, this.convertMsg(data.get(i)));
}
}
if (this.remark != null && !StringUtils.isBlank(this.remark.getValue())) {
jd.put("remark", this.convertMsg(this.remark));
}
obj.put("data", jd);
return obj.toJSONString();
}
public JSONObject convertMsg(MsgData msg) {
JSONObject jb = new JSONObject();
jb.put("value", msg.getValue());
jb.put("color", msg.getColor());
return jb;
}
public static void main(String[] args) {
WxSendMsgVO ws = new WxSendMsgVO();
ws.setOpenId("OPENID12345698979");
ws.setTemplemteId("TEMPLETEID789465");
ws.setUrl("http://baidu.com");
ws.setWxAppltAppId("APPLETID123");
ws.setAppletPath("pages-tx/jiafang/order/detail/index?taskId=123");
List<MsgData> list = new ArrayList<MsgData>();
MsgData m1 = new MsgData();
m1.setValue("111");
m1.setColor("#66699955");
list.add(m1);
MsgData m2 = new MsgData();
m2.setValue("222");
m2.setColor("#66699955");
list.add(m2);
ws.setData(list);
MsgData title = new MsgData();
title.setColor("gray");
title.setValue("我的标题");
ws.setTitle(title);
String json = ws.buildMsgJson();
System.out.println(json);
}
}
src/main/java/com/mmc/oms/service/CouponBackService.java 0 → 100644
package com.mmc.oms.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.mmc.oms.common.ResultBody;
import com.mmc.oms.entity.CouponDO;
import com.mmc.oms.model.dto.CouponActivityDTO;
import com.mmc.oms.model.dto.CouponDTO;
import com.mmc.oms.model.qo.CouponInfoQO;
import com.mmc.oms.model.qo.CouponUserInfoQO;
import com.mmc.oms.model.qo.ProductCouponQO;
import com.mmc.oms.model.vo.CouponInfoActivityVO;
import com.mmc.oms.model.vo.CouponInfoVO;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 13:28
* @Version 1.0
*/
public interface CouponBackService extends IService<CouponDO> {
/**
* 创建-优惠券
* @param couponVO
* @return
*/
ResultBody saveCouponBackInfo(CouponInfoVO couponVO, MultipartFile file);
/**
* 创建-裂变优惠券
* @param couponInfoActivityVO
* @return
*/
ResultBody saveActivityCouponInfo(CouponInfoActivityVO couponInfoActivityVO);
/**
* 查询分页列表-优惠券
* @param couponInfoQO
* @return
*/
ResultBody pageCouponList(CouponInfoQO couponInfoQO);
/**
* 查询分页列表-裂变优惠券
* @param couponInfoQO
* @return
*/
ResultBody pageActivityCouponList(CouponInfoQO couponInfoQO);
/**
* 裂变优惠券-下拉
* @return
*/
ResultBody getActivityCouponPullDown(Integer type);
/**
* 根据id修改优惠券发放数量
* @param id
* @param count
* @return
*/
ResultBody increaseCouponCount(Integer id,Integer count);
/**
* 根据id修改优惠卷状态
* @param id
* @return
*/
ResultBody shutDown(Integer id);
/**
* 获取优惠券使用数据
* @param id 优惠券id
* @return
*/
ResultBody couponViewData(Integer id);
/**
* 获取优惠卷明细列表
* @param couponUserInfoQO
* @return
*/
ResultBody getCouponUserList(CouponUserInfoQO couponUserInfoQO);
/**
* 优惠卷明细列表导出
* @param response
* @param couponUserInfoQO
* @throws IOException
*/
void downloadCouponUserList(HttpServletResponse response, CouponUserInfoQO couponUserInfoQO) throws IOException;
/**
* 获取优惠卷详情
* @param ids id
* @return
*/
List<CouponDTO> feignByIds(List<Integer> ids);
/**
* 根据id获取裂变优惠券详情
* @param id
* @return
*/
CouponActivityDTO getCouponActivityById(Integer id);
/**
* 根据id获取裂变优惠券详情
* @param id
* @return
*/
List<CouponActivityDTO> getCouponActivityList(List<Integer> id);
/**
* 扣减数量
* @param id 优惠券id
* @param num 数量
* @param isLimited 是否限量
*/
Boolean deduction(Integer id, Integer num, Boolean isLimited);
/**
* 批量更改优惠券状态
*/
void overdueCouponTask();
List<CouponDTO> feignGetCouponType(Integer type);
ResultBody ordinaryActivities(ProductCouponQO productCouponQO);
ResultBody fissionActivity(ProductCouponQO productCouponQO);
}
src/main/java/com/mmc/oms/service/CouponUserService.java 0 → 100644
package com.mmc.oms.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.mmc.oms.common.ResultBody;
import com.mmc.oms.entity.CouponUserDO;
import com.mmc.oms.model.dto.BaseAccountDTO;
import com.mmc.oms.model.dto.CouponUserDTO;
import com.mmc.oms.model.dto.CouponUserOrderDTO;
import com.mmc.oms.model.dto.OrderCouponDTO;
import com.mmc.oms.model.vo.CouponUserExchangeVO;
import com.mmc.oms.model.vo.CouponUserVO;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 14:45
* @Version 1.0
*/
public interface CouponUserService extends IService<CouponUserDO> {
/**
* 查询我的优惠券
* @param status 优惠券状态 1：已使用, 2:已失效，3:已转赠
* @param pageNo 页码
* @param pageSize 每页数
* @param currentAccount 用户信息
* @return
*/
ResultBody getMyList(Integer status,Integer pageNo,Integer pageSize,BaseAccountDTO currentAccount);
/**
* 领取优惠券
* @param id 优惠券id
* @param currentAccount 用户信息
* @return
*/
ResultBody receiveCoupon(Integer id, BaseAccountDTO currentAccount);
/**
* 批量领取优惠券
* @param id 优惠券id
* @param currentAccount 用户信息
* @return
*/
ResultBody receiveCouponList(List<Integer> id, BaseAccountDTO currentAccount);
/**
* 转增优惠券
* @param id 优惠券
* @param uid 用户uid
* @return
*/
ResultBody presentedCoupon(Integer id,String uid,BaseAccountDTO currentAccount);
/**
* 获取可领取优惠券列表
* @param priority 品牌id,搜索品牌指定优惠卷
* @param pageNo 页码
* @param pageSize 每页数
* @return
*/
ResultBody getList(List<Integer> priority,Integer pageNo,Integer pageSize,BaseAccountDTO currentAccount);
/**
* 根据品牌获取可用优惠券
* @param primaryKey 品牌id
* @param uid 用户信息
* @return
*/
List<CouponUserOrderDTO> getUsableCoupon(List<Integer> primaryKey, Integer uid);
/**
* 根据id获取我的优惠券详情
* @param couponId id
* @return
*/
List<CouponUserDTO> feignGetById(List<Integer> couponId);
/**
* 下单修改我的优惠券
* @param couponUserVO 优惠券记录表修改VO
* @return
*/
Boolean feignUpMyCoupon(List<CouponUserVO> couponUserVO);
Boolean feignExchangeCoupon(CouponUserExchangeVO couponUserExchangeVO);
/**
* 优惠券定时过期任务
*/
void overdueTask();
List<CouponUserOrderDTO> feignListUserCouponsByIds(List<Integer> couponIds);
List<CouponUserDTO> feignOrderCoupon(String orderNumber);
/**
* 优惠券回退
* @param orderCouponDTOS
* @return
*/
Boolean feignRollbackCoupons(List<OrderCouponDTO> orderCouponDTOS);
ResultBody couponMerchandise(Integer couponId,String productName,Integer useType);
ResultBody couponUsageDetails(Integer uid);
}
src/main/java/com/mmc/oms/service/Impl/CouponBackServiceImpl.java 0 → 100644
package com.mmc.oms.service.Impl;
import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelReader;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mmc.oms.common.*;
import com.mmc.oms.dao.CouponBackDao;
import com.mmc.oms.dao.CouponUserDao;
import com.mmc.oms.entity.ChannelCouponDO;
import com.mmc.oms.entity.CouponDO;
import com.mmc.oms.entity.CouponUserDO;
import com.mmc.oms.entity.ProductInformationDo;
import com.mmc.oms.model.dto.*;
import com.mmc.oms.model.qo.CouponInfoQO;
import com.mmc.oms.model.qo.CouponUserInfoQO;
import com.mmc.oms.model.qo.ProductCouponQO;
import com.mmc.oms.model.vo.CouponInfoActivityVO;
import com.mmc.oms.model.vo.CouponInfoVO;
import com.mmc.oms.service.CouponBackService;
import com.mmc.oms.service.CouponUserService;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Author small
* @Date 2023/5/24 14:42
* @Version 1.0
*/
@Service
public class CouponBackServiceImpl extends ServiceImpl<CouponBackDao, CouponDO> implements CouponBackService {
@Resource
private CouponUserService couponUserService;
//@Autowired
//private MallUserClient mallUserClient;
//@Autowired
//private MallOrderClient mallOrderClient;
@Autowired
private TransactionTemplate transactionTemplate;
@Resource
private CouponUserDao couponUserDao;
@Resource
private CouponBackDao couponBackDao;
@Override
public ResultBody saveCouponBackInfo(CouponInfoVO couponVO, MultipartFile file) {
LambdaQueryWrapper<CouponDO> wrapper = new LambdaQueryWrapper();
wrapper.eq(CouponDO::getCouponName, couponVO.getCouponName()).eq(CouponDO::getIsDel, false);
long count = this.count(wrapper);
if (count > 0) {
return ResultBody.error("优惠券名重复");
}
if (CouponConstants.COUPON_TYPE_REDUCED.equals(couponVO.getCouponType())){
int flag = couponVO.getMinPrice().compareTo(couponVO.getCouponMoney());
if (flag < 0){
return ResultBody.error("优惠券最低消费不能小于面值");
}
}
CouponDO couponDO = new CouponDO(couponVO);
couponDO.setLastTotal(couponVO.getCouponTotal());
couponDO.setCreateTime(new Date());
boolean save = this.save(couponDO);
CouponDTO couponDTO = couponDO.bilIdCouponDTO();
//批量导入用户
if (file != null){
List<ChannelCouponDO> channelCouponDOS = redeExcel(file);
List<String> uid = new ArrayList<>();
List<String> phone = new ArrayList<>();
for (ChannelCouponDO channelCouponDO : channelCouponDOS) {
if (StringUtils.isNotBlank(channelCouponDO.getUid())){
uid.add(channelCouponDO.getUid());
}else {
phone.add(channelCouponDO.getUserPhone());
}
}
//远程调用 批量查询用户信息
List<MallUserDTO> mallUserDTOS =null;
//mallUserClient.feignGetListUserDTO(uid, phone);
if(mallUserDTOS!=null && mallUserDTOS.size() > 0){
//查看当前优惠券剩余量
if (couponDO.getIsLimited() && couponDO.getLastTotal() < mallUserDTOS.size()){
return ResultBody.error("当前剩余量不够领取");
}
List<CouponUserDO> couponUserList = extracted(couponDO, mallUserDTOS);
Boolean execute = transactionTemplate.execute(e -> {
couponUserService.saveBatch(couponUserList);
//扣减数量
deduction(couponDO.getId(), couponUserList.size(), couponDO.getIsLimited());
return Boolean.TRUE;
});
}
}
if (save) {
return ResultBody.success(couponDTO);
} else {
return ResultBody.error("请稍后重试");
}
}
@Override
public ResultBody saveActivityCouponInfo(CouponInfoActivityVO couponInfoActivityVO) {
LambdaQueryWrapper<CouponDO> wrapper = new LambdaQueryWrapper();
wrapper.eq(CouponDO::getCouponName, couponInfoActivityVO.getCouponName()).eq(CouponDO::getIsDel, false);
long count = this.count(wrapper);
if (count > 0) {
return ResultBody.error("优惠券名重复");
}
if (CouponConstants.COUPON_TYPE_REDUCED.equals(couponInfoActivityVO.getCouponType()) ||
CouponConstants.COUPON_TYPE_REDUCED.equals(couponInfoActivityVO.getBeSharedCouponType())){
int flag = couponInfoActivityVO.getMinPrice().compareTo(couponInfoActivityVO.getCouponMoney());
int i = couponInfoActivityVO.getBeSharedMinPrice().compareTo(couponInfoActivityVO.getBeSharedCouponMoney());
if (flag < 0 || i < 0){
return ResultBody.error("优惠券最低消费不能小于面值");
}
}
if (couponInfoActivityVO.getBeSharedCouponTotal() < couponInfoActivityVO.getCouponTotal()){
return ResultBody.error("被分享者券发行量应大于等于分享者券发行量*分享人数*1.5");
}
CouponDO couponDO = new CouponDO(couponInfoActivityVO);
couponDO.setLastTotal(couponInfoActivityVO.getCouponTotal());
couponDO.setCreateTime(new Date());
couponDO.setIsLimited(true);
CouponDO couponActivity = new CouponDO(couponInfoActivityVO, 1);
couponActivity.setLastTotal(couponInfoActivityVO.getBeSharedCouponTotal());
couponActivity.setCreateTime(new Date());
Boolean execute = transactionTemplate.execute(e -> {
this.save(couponDO);
couponActivity.setParentId(couponDO.getId());
this.save(couponActivity);
return Boolean.TRUE;
});
if (execute){
return ResultBody.success();
} else {
return ResultBody.error("请稍后重试");
}
}
private List<CouponUserDO> extracted(CouponDO couponDO, List<MallUserDTO> result) {
Integer couponDay = couponDO.getCouponDay();
DateTime date = DateUtil.date();
List<CouponUserDO> couponUserList = new ArrayList<>();
//优惠券有效期使用时间
if (CouponConstants.COUPON_USE_TIME_THE_DAY.equals(couponDO.getIsFixedTime())){
//领取当日起
couponDO.setUseStartTime(date);
couponDO.setUseEndTime(DateUtil.offsetDay(date, couponDay));
}else if (CouponConstants.COUPON_USE_TIME_NEXT_DAY.equals(couponDO.getIsFixedTime())){
//领取次日起
DateTime dateTime = DateUtil.offsetDay(date, 1);
couponDO.setUseStartTime(dateTime);
couponDO.setUseEndTime(DateUtil.offsetDay(dateTime, couponDay));
}else {
couponDO.setUseStartTime(couponDO.getUseStartTime());
couponDO.setUseEndTime(couponDO.getUseEndTime());
}
Integer restrictedAccess = couponDO.getRestrictedAccess();
for (int i = 0; i < result.size(); i++) {
for (Integer integer = 0; integer < restrictedAccess; integer++) {
CouponUserDO couponUserDO = new CouponUserDO(couponDO);
couponUserDO.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_SEND);
couponUserDO.setCreateTime(date);
MallUserDTO mallUserDTO = result.get(i);
couponUserDO.setUid(mallUserDTO.getId());
couponUserDO.setUuid(mallUserDTO.getUid());
couponUserDO.setUserPhone(mallUserDTO.getPhoneNum());
couponUserList.add(couponUserDO);
}
}
return couponUserList;
}
@Override
public ResultBody pageCouponList(CouponInfoQO couponInfoQO) {
LambdaQueryWrapper<CouponDO> queryWrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotBlank(couponInfoQO.getCouponName())) {
queryWrapper.like(CouponDO::getCouponName, couponInfoQO.getCouponName());
}
if (StringUtils.isNotBlank(couponInfoQO.getCouponId())) {
queryWrapper.like(CouponDO::getId, couponInfoQO.getCouponId());
}
if (couponInfoQO.getState() != null){
queryWrapper.eq(CouponDO::getCouponStatus, couponInfoQO.getState());
}
if (StringUtils.isNotBlank(couponInfoQO.getStartTime())){
queryWrapper.ge(CouponDO::getCreateTime, couponInfoQO.getStartTime());
}
if (StringUtils.isNotBlank(couponInfoQO.getEndTime())){
queryWrapper.le(CouponDO::getCreateTime, couponInfoQO.getEndTime());
}
queryWrapper.eq(CouponDO::getIsDel, false);
queryWrapper.eq(CouponDO::getUseType, couponInfoQO.getUseType());
queryWrapper.orderByDesc(CouponDO::getCreateTime);
Page<CouponDO> pages = new Page<>(couponInfoQO.getPageNo(), couponInfoQO.getPageSize());
Page<CouponDO> pageInfo = this.page(pages, queryWrapper);
List<CouponDTO> collect = pageInfo.getRecords().stream().map(CouponDO::bilIdCouponDTO)
.collect(Collectors.toList());
PageResult pageResult = PageResult.buildPage(couponInfoQO.getPageNo(), couponInfoQO.getPageSize(),
(int) pageInfo.getTotal(), collect);
return ResultBody.success(pageResult);
}
@Override
public ResultBody pageActivityCouponList(CouponInfoQO couponInfoQO) {
LambdaQueryWrapper<CouponDO> queryWrapper = new LambdaQueryWrapper<>();
if (StringUtils.isNotBlank(couponInfoQO.getCouponName())) {
queryWrapper.like(CouponDO::getCouponName, couponInfoQO.getCouponName());
}
if (StringUtils.isNotBlank(couponInfoQO.getCouponId())) {
queryWrapper.like(CouponDO::getId, couponInfoQO.getCouponId());
}
if (couponInfoQO.getState() != null){
queryWrapper.eq(CouponDO::getCouponStatus, couponInfoQO.getState());
}
queryWrapper.eq(CouponDO::getIsDel, false);
queryWrapper.eq(CouponDO::getGetType, CouponConstants.COUPON_USR_TYPE_ACTIVITY);
queryWrapper.eq(CouponDO::getUseType, couponInfoQO.getUseType());
queryWrapper.isNull(CouponDO::getParentId);
queryWrapper.orderByDesc(CouponDO::getCreateTime);
Page<CouponDO> pages = new Page<>(couponInfoQO.getPageNo(), couponInfoQO.getPageSize());
Page<CouponDO> pageInfo = this.page(pages, queryWrapper);
List<CouponActivityDTO> collect = pageInfo.getRecords().stream().map(CouponDO::bilIdCouponActivityDTO)
.collect(Collectors.toList());
for (CouponActivityDTO couponActivityDTO : collect) {
LambdaQueryWrapper<CouponDO> activityWrapper = new LambdaQueryWrapper<>();
activityWrapper.eq(CouponDO::getParentId,couponActivityDTO.getId());
CouponActivityDTO activityDTO = this.getOne(activityWrapper).bilIdCouponActivityDTO();
activityDTO.setActivityRole("beShare");
couponActivityDTO.setBeSharedCoupon(activityDTO);
}
PageResult pageResult = PageResult.buildPage(couponInfoQO.getPageNo(), couponInfoQO.getPageSize(),
(int) pageInfo.getTotal(), collect);
return ResultBody.success(pageResult);
}
@Override
public ResultBody getActivityCouponPullDown(Integer type) {
LambdaQueryWrapper<CouponDO> queryWrapper = new LambdaQueryWrapper<>();
if (type == 2){
queryWrapper.eq(CouponDO::getGetType,CouponConstants.COUPON_ISSUE_TYPE_INITIATIVE);
}else {
queryWrapper.eq(CouponDO::getGetType, CouponConstants.COUPON_USR_TYPE_ACTIVITY);
queryWrapper.isNull(CouponDO::getParentId);
}
queryWrapper.eq(CouponDO::getIsDel, false);
queryWrapper.orderByDesc(CouponDO::getCreateTime);
List<CouponDO> list = this.list(queryWrapper);
List<CouponActivityDTO> collect = list.stream().map(CouponDO::bilIdCouponActivityDTO)
.collect(Collectors.toList());
for (CouponActivityDTO couponActivityDTO : collect) {
LambdaQueryWrapper<CouponDO> activityWrapper = new LambdaQueryWrapper<>();
activityWrapper.eq(CouponDO::getParentId,couponActivityDTO.getId());
CouponDO one = this.getOne(activityWrapper);
if (one != null){
CouponActivityDTO activityDTO = one.bilIdCouponActivityDTO();
activityDTO.setActivityRole("beShare");
couponActivityDTO.setBeSharedCoupon(activityDTO);
}else {
couponActivityDTO.setActivityRole(null);
}
}
return ResultBody.success(collect);
}
@Override
public ResultBody increaseCouponCount(Integer id, Integer count) {
if (count < 0) {
return ResultBody.error("数量小于0");
}
CouponDO coupon = this.getById(id);
if (coupon == null) {
return ResultBody.error("数据不存在!");
}
//发放总数
Integer couponTotal = coupon.getCouponTotal();
Integer newCouponTotal = couponTotal + count;
//剩余数量
Integer lastTotal = coupon.getLastTotal();
Integer newLastTotal = lastTotal + count;
LambdaUpdateWrapper<CouponDO> update = new LambdaUpdateWrapper();
update.eq(CouponDO::getId, id)
.set(CouponDO::getCouponTotal, newCouponTotal)
.set(CouponDO::getLastTotal,newLastTotal);
boolean updateStatus = update(update);
if (updateStatus){
return ResultBody.success();
}else {
return ResultBody.error("增发失败,请稍后再试");
}
}
@Override
public ResultBody shutDown(Integer id) {
CouponDO couponDO = getById(id);
if (couponDO == null){
return ResultBody.error("该优惠券不存在");
}
LambdaQueryWrapper<CouponDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CouponDO::getParentId,couponDO.getId());
List<CouponDO> list = list(queryWrapper);
if (list.size() > 0){
CouponDO coupon = list.get(0);
LambdaUpdateWrapper<CouponDO> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(CouponDO::getId,coupon.getId()).set(CouponDO::getCouponStatus,false);
update(updateWrapper);
}
LambdaUpdateWrapper<CouponDO> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(CouponDO::getId,id).set(CouponDO::getCouponStatus,false);
boolean update = update(updateWrapper);
if (update){
return ResultBody.success();
}else {
return ResultBody.error("关闭失败,请稍后再试");
}
}
@Override
public ResultBody couponViewData(Integer id) {
DecimalFormat df = new DecimalFormat("0.00");
//总发行量
CouponDO couponInfo = this.getById(id);
if (couponInfo == null){
return ResultBody.error("该优惠券不存在");
}
Integer couponTotal = couponInfo.getCouponTotal();
//领取量：用户成功领取的券数；
LambdaQueryWrapper<CouponUserDO> queryWrap = new LambdaQueryWrapper<>();
queryWrap.eq(CouponUserDO::getCouponId,id);
queryWrap.ne(CouponUserDO::getStatus, CouponConstants.STORE_COUPON_USER_STATUS_PRESENTED);
long receiveQuantity = couponUserService.count(queryWrap);
//领取率：(领取量 / 总发行量) * 100%；
String claimRate = df.format(((float)receiveQuantity / (float)couponTotal) * 100) + "%";
//订单中心
List<Long> collect = couponUserDao.getOrderList(id);
ResultBody resultBody = null;
if (collect.size() > 0){
resultBody = null;
//mallOrderClient.feignOrderUseCoupon(collect);
}
//用户待付款订单使用的优惠券数量
Integer obligation = 0;
//已付款订单使用的优惠券数量 = 有效使用量：用户结算的时候，成功使用优惠券进行抵扣金额的优惠券数量（已付款订单）
Integer accountPaid = 0;
if (resultBody != null){
Map<String,Integer> result = (Map<String, Integer>) resultBody.getResult();
obligation = result.get("obligation");
accountPaid = result.get("accountPaid");
}
//使用量：用户待付款订单使用的优惠券数量 + 已付款订单使用的优惠券数量；
Integer usageAmount = obligation + accountPaid;
String availability;
//有效使用率：(有效使用量 / 使用量) * 100%；
if (usageAmount <= 0 ){
availability = 0 + "%";
}else {
availability = df.format(((float)accountPaid / (float)usageAmount) * 100) + "%";
}
CouponViewDTO couponViewDTO = new CouponViewDTO();
couponViewDTO.setCouponTotal(couponTotal);
couponViewDTO.setReceiveQuantity(receiveQuantity);
couponViewDTO.setClaimRate(claimRate);
couponViewDTO.setAccountPaid(accountPaid);
couponViewDTO.setUsageAmount(usageAmount);
couponViewDTO.setAvailability(availability);
return ResultBody.success(couponViewDTO);
}
@Override
public ResultBody getCouponUserList(CouponUserInfoQO couponUserInfoQO) {
Integer integer = couponUserDao.selectCouponUserInfoCount(couponUserInfoQO);
couponUserInfoQO.buildCurrentPage();
List<CouponUserDTO> couponUserDTOS = couponUserDao.selectCouponUserInfoList(couponUserInfoQO);
PageResult pageResult = PageResult.buildPage(couponUserInfoQO.getPageNo() + 1,
couponUserInfoQO.getPageSize(), integer, couponUserDTOS);
return ResultBody.success(pageResult);
}
@Override
public void downloadCouponUserList(HttpServletResponse response, CouponUserInfoQO couponUserInfoQO) throws IOException {
couponUserInfoQO.setPageNo(0);
Integer integer = couponUserDao.selectCouponUserInfoCount(couponUserInfoQO);
couponUserInfoQO.setPageSize(integer);
List<CouponUserDTO> couponUserDTOS = couponUserDao.selectCouponUserInfoList(couponUserInfoQO);
List<CouponUserExcel> datas = couponUserDTOS.stream()
.map(this::buildExUavMallAccount).collect(Collectors.toList());
Collection<CouponUserExcel> coll = datas;
Workbook workbook = ExcelExportUtil.exportExcel(
new ExportParams("优惠券明细数据", "优惠券明细"), CouponUserExcel.class, coll);
String fileName = "优惠券明细" + TDateUtil.getCurrentDate();
fileName = URLEncoder.encode(fileName, "UTF8");
response.setContentType("application/vnd.ms-excel;chartset=utf-8");
response.setHeader("Content-Disposition", "attachment; filename=\"" + fileName + ".xls\"");
ServletOutputStream out = response.getOutputStream();
workbook.write(out);
out.flush();
out.close();
}
@Override
public List<CouponDTO> feignByIds(List<Integer> ids) {
List<CouponDO> couponDOS = this.listByIds(ids);
return couponDOS.stream().map(CouponDO::bilIdCouponDTO).collect(Collectors.toList());
}
@Override
public CouponActivityDTO getCouponActivityById(Integer id) {
CouponActivityDTO couponActivityDTO = this.getById(id).bilIdCouponActivityDTO();
LambdaQueryWrapper<CouponDO> activityWrapper = new LambdaQueryWrapper<>();
activityWrapper.eq(CouponDO::getParentId,couponActivityDTO.getId());
CouponActivityDTO activityDTO = this.getOne(activityWrapper).bilIdCouponActivityDTO();
activityDTO.setActivityRole("beShare");
couponActivityDTO.setBeSharedCoupon(activityDTO);
return couponActivityDTO;
}
@Override
public List<CouponActivityDTO> getCouponActivityList(List<Integer> id) {
List<CouponActivityDTO> collect = this.listByIds(id).stream().map(CouponDO::bilIdCouponActivityDTO)
.collect(Collectors.toList());
for (CouponActivityDTO couponActivityDTO : collect) {
if (couponActivityDTO.getParentId() != null){
LambdaQueryWrapper<CouponDO> activityWrapper = new LambdaQueryWrapper<>();
activityWrapper.eq(CouponDO::getParentId,couponActivityDTO.getId());
CouponActivityDTO activityDTO = this.getOne(activityWrapper).bilIdCouponActivityDTO();
activityDTO.setActivityRole("beShare");
couponActivityDTO.setBeSharedCoupon(activityDTO);
}
}
return collect;
}
@Override
public Boolean deduction(Integer id, Integer num, Boolean isLimited) {
UpdateWrapper<CouponDO> updateWrapper = new UpdateWrapper<>();
if (isLimited) {
updateWrapper.setSql(StrUtil.format("last_total = last_total - {}", num));
updateWrapper.last(StrUtil.format(" and (last_total - {} >= 0)", num));
} else {
updateWrapper.setSql(StrUtil.format("last_total = last_total + {}", num));
}
updateWrapper.eq("id", id);
return update(updateWrapper);
}
public List<ChannelCouponDO> redeExcel(MultipartFile file){
EasyExcelListener<ChannelCouponDO> listener = new EasyExcelListener<ChannelCouponDO>();
ExcelReader build = null;
try {
build = EasyExcel.read(file.getInputStream(), ChannelCouponDO.class, listener).headRowNumber(1).build();
} catch (IOException e) {
throw new RuntimeException(e);
}
build.readAll();
List<ChannelCouponDO> cachedDataList = listener.getCachedDataList();
build.finish();
return cachedDataList;
}
private CouponUserExcel buildExUavMallAccount(CouponUserDTO m) {
String type = null;
if (CouponConstants.STORE_COUPON_USER_TYPE_GET.equals(m.getGainType())) {
type = "用户领取";
} else if (CouponConstants.STORE_COUPON_USER_TYPE_SEND.equals(m.getCouponType())) {
type = "后台发放";
} else if (CouponConstants.STORE_COUPON_USER_TYPE_PRESENTED.equals(m.getCouponType())) {
type = "赠送";
}else if (CouponConstants.STORE_COUPON_USER_TYPE_ACQUIRE.equals(m.getCouponType())) {
type = "获赠";
}else if (CouponConstants.STORE_COUPON_USER_TYPE_EXCHANGE.equals(m.getCouponType())) {
type = "兑换";
}else if (CouponConstants.STORE_COUPON_USER_TYPE_ACTIVITY.equals(m.getCouponType())) {
type = "活动领取";
}
String status = null;
if (CouponConstants.STORE_COUPON_USER_STATUS_USABLE.equals(m.getStatus())) {
status = "未使用";
} else if (CouponConstants.STORE_COUPON_USER_STATUS_USED.equals(m.getStatus())) {
status = "已使用";
} else if (CouponConstants.STORE_COUPON_USER_STATUS_LAPSED.equals(m.getStatus())) {
status = "已失效";
}else if (CouponConstants.STORE_COUPON_USER_STATUS_PRESENTED.equals(m.getStatus())) {
status = "已转赠";
}else if (CouponConstants.STORE_COUPON_USER_STATUS_IN_USE.equals(m.getStatus())) {
status = "使用中";
}
String entAuthStatus = null;
if (m.getVerificationType() != null && m.getVerificationType()) {
entAuthStatus = "多次核销";
} else {
entAuthStatus = "单次核销";
}
String transform = null;
if (m.getConversionRatio() != null){
transform = "1:" + m.getConversionRatio();
}
return CouponUserExcel.builder()
.couponId(m.getCouponId())
.uid(m.getUid())
.userPhone(m.getUserPhone())
.couponName(m.getCouponName())
.gainType(type)
.status(status)
.createTime(m.getCreateTime())
.useTime(m.getUseTime())
.orderNo(m.getOrderNo()).build();
}
@Override
public void overdueCouponTask() {
// 查询所有状态——可用的优惠券
LambdaQueryWrapper<CouponDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CouponDO::getCouponStatus, true);
queryWrapper.eq(CouponDO::getIsDel, false);
queryWrapper.eq(CouponDO::getIsFixedTime, CouponConstants.COUPON_USE_TIME_FIXED);
List<CouponDO> list = this.list(queryWrapper);
if (CollUtil.isEmpty(list)){
return;
}
List<CouponDO> updateList = CollUtil.newArrayList();
list.forEach(coupon -> {
if (ObjectUtil.isNotNull(coupon.getUseEndTime())) {
if (DateUtil.date().after(coupon.getUseEndTime())) {
coupon.setCouponStatus(false);
updateList.add(coupon);
}
}
});
if (CollUtil.isEmpty(updateList)){
return;
}
boolean update = this.updateBatchById(updateList);
if (!update){
log.error("批量更新优惠券状态动作失败");
}
}
@Override
public List<CouponDTO> feignGetCouponType(Integer type) {
LambdaQueryWrapper<CouponDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CouponDO::getIsDel, false);
queryWrapper.eq(CouponDO::getGetType, CouponConstants.COUPON_ISSUE_TYPE_INITIATIVE);
queryWrapper.eq(CouponDO::getUserTag, type);
List<CouponDO> list = this.list(queryWrapper);
List<CouponDTO> collect = list.stream().map(CouponDO::bilIdCouponDTO).collect(Collectors.toList());
return collect;
}
@Override
public ResultBody ordinaryActivities(ProductCouponQO productCouponQO) {
Integer goodsInfoId = productCouponQO.getGoodsInfoId();
ProductInformationDo product = couponBackDao.findProduct(goodsInfoId);
if (product==null){
return ResultBody.error("当前商品没有优惠券");
}
List<CouponDO> couponDOS = couponBackDao.ordinaryActivities(product.getBrandId());
List<CouponDTO> collect = couponDOS.stream().map(CouponDO::bilIdCouponDTO).collect(Collectors.toList());
PageResult pageResult = PageResult.buildPage(productCouponQO.getPageNo(), productCouponQO.getPageSize(), collect.size(), collect);
return ResultBody.success(pageResult);
}
@Override
public ResultBody fissionActivity(ProductCouponQO productCouponQO) {
Integer goodsInfoId = productCouponQO.getGoodsInfoId();
ProductInformationDo product = couponBackDao.findProduct(goodsInfoId);
if (product==null){
return ResultBody.error("当前商品没有优惠券");
}
List<CouponDO> couponDOS = couponBackDao.fissionActivity(product.getBrandId());
List<CouponDTO> collect = couponDOS.stream().map(CouponDO::bilIdCouponDTO).collect(Collectors.toList());
PageResult pageResult = PageResult.buildPage(productCouponQO.getPageNo(), productCouponQO.getPageSize(), collect.size(), collect);
return ResultBody.success(pageResult);
}
}
src/main/java/com/mmc/oms/service/Impl/CouponUserServiceImpl.java 0 → 100644
package com.mmc.oms.service.Impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.util.DateUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mmc.oms.common.*;
import com.mmc.oms.config.FlyerSystemConstant;
import com.mmc.oms.dao.CouponBackDao;
import com.mmc.oms.dao.CouponUserDao;
import com.mmc.oms.entity.CouponDO;
import com.mmc.oms.entity.CouponUsageDetailsDO;
import com.mmc.oms.entity.CouponUserDO;
import com.mmc.oms.entity.GoodsInfoDO;
import com.mmc.oms.model.dto.*;
import com.mmc.oms.model.qo.CouponUserInfoQO;
import com.mmc.oms.model.vo.AppletMsgVO;
import com.mmc.oms.model.vo.CouponUserExchangeVO;
import com.mmc.oms.model.vo.CouponUserVO;
import com.mmc.oms.model.vo.WxSendMsgVO;
import com.mmc.oms.service.CouponBackService;
import com.mmc.oms.service.CouponUserService;
import com.mmc.oms.wx.WxMsgTemplete;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
/**
* @Author small
* @Date 2023/5/24 16:07
* @Version 1.0
*/
@Service
@Slf4j
public class CouponUserServiceImpl extends ServiceImpl<CouponUserDao, CouponUserDO> implements CouponUserService {
@Resource
private CouponBackService couponBackService;
@Autowired
private TransactionTemplate transactionTemplate;
// @Autowired
//private MallUserClient mallUserClient;
@Resource
private CouponUserDao couponUserDao;
@Resource
private CouponBackDao couponBackDao;
// @Autowired
// private UserServletClient userServletClient;
//VIP优惠券
private final Integer VIPCOUPON=1;
private final Integer BRAND_COUPONS=2;
@Override
public ResultBody getMyList(Integer status,Integer pageNo,Integer pageSize, BaseAccountDTO currentAccount) {
Integer uid = currentAccount.getId();
LambdaQueryWrapper<CouponUserDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CouponUserDO::getUid, uid);
if (status == null) {
// 未使用及使用中
queryWrapper.and(wq -> wq.eq(CouponUserDO::getStatus, CouponConstants.STORE_COUPON_USER_STATUS_USABLE)
.or().eq(CouponUserDO::getStatus, CouponConstants.STORE_COUPON_USER_STATUS_IN_USE));
} else {
queryWrapper.and(wq -> wq.eq(CouponUserDO::getStatus, status));
}
queryWrapper.orderByDesc(CouponUserDO::getCreateTime);
Page<CouponUserDO> pages = new Page<>(pageNo,pageSize);
Page<CouponUserDO> pageInfo = this.page(pages, queryWrapper);
List<CouponUserDTO> collect = pageInfo.getRecords().stream().map(CouponUserDO::bilIdCouponDTO)
.collect(Collectors.toList());
PageResult pageResult = PageResult.buildPage(pageNo,pageSize, (int) pageInfo.getTotal(), collect);
return ResultBody.success(pageResult);
}
@Override
public ResultBody receiveCoupon(Integer id, BaseAccountDTO currentAccount) {
//获取优惠券信息
CouponDO couponDO = couponBackService.getById(id);
if (couponDO == null){
return ResultBody.error("暂无该优惠券");
}
//查看优惠券状态 开启并且未删除
if (!couponDO.getCouponStatus() || couponDO.getIsDel()) {
return ResultBody.error("该优惠券已结束,不可领取");
}
//查看当前优惠券剩余量
if (couponDO.getIsLimited() && couponDO.getLastTotal() < 1) {
return ResultBody.error("当前剩余量不够领取");
}
//判定当前领取人 认证相关信息
// if (couponDO.getUserTag() != null){
// Integer useTag = couponDO.getUserTag();
// MallUserDTO mallUserDTO = mallUserClient.feignGetSimpleUserInfo(currentAccount.getId());
// System.out.println("mallUserDTO-----------------------"+ mallUserDTO);
// if (CouponConstants.USER_LABEL_REAL_NAME_AUTHENTICATION.equals(useTag) && mallUserDTO.getRealAuthStatus() != 1 ){
// return ResultBody.error("该用户实名认证未通过");
// }
// if (CouponConstants.USER_LABEL_ENTERPRISE_CERTIFICATION.equals(useTag) && mallUserDTO.getEntVerifyStatus() != 1){
// return ResultBody.error("该用户企业认证未通过");
// }
// }
if (!couponDO.getGetType().equals(CouponConstants.COUPON_USR_TYPE_ACTIVITY)){
//查看当前优惠券是否限制每人领取
LambdaQueryWrapper<CouponUserDO> queryWrap = new LambdaQueryWrapper<>();
queryWrap.eq(CouponUserDO::getUid, currentAccount.getId()).eq(CouponUserDO::getCouponId, id);
long count = this.count(queryWrap);
if (count >= couponDO.getRestrictedAccess()) {
return ResultBody.error("已领取,不可重复领取");
}
}
//优惠券有效期使用时间
Integer couponDay = couponDO.getCouponDay();
DateTime date = DateUtil.date();
if (CouponConstants.COUPON_USE_TIME_THE_DAY.equals(couponDO.getIsFixedTime())) {
//领取当日起
couponDO.setUseStartTime(date);
couponDO.setUseEndTime(DateUtil.offsetDay(date, couponDay));
} else if (CouponConstants.COUPON_USE_TIME_NEXT_DAY.equals(couponDO.getIsFixedTime())) {
//领取次日起
DateTime dateTime = DateUtil.offsetDay(date, 1);
couponDO.setUseStartTime(dateTime);
couponDO.setUseEndTime(DateUtil.offsetDay(dateTime, couponDay));
}
CouponUserDO couponUser = new CouponUserDO(couponDO);
couponUser.setUid(currentAccount.getId());
couponUser.setUuid(currentAccount.getUid());
couponUser.setUserPhone(currentAccount.getAccountPhone());
//如果优惠券是活动券 则为活动领取
if (CouponConstants.COUPON_USR_TYPE_ACTIVITY.equals(couponDO.getGetType())){
couponUser.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_ACTIVITY);
//如果优惠券用户标签不为空 则为系统发放
}else if (couponDO.getUserTag() != null){
couponUser.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_SEND);
} else {
couponUser.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_GET);
}
couponUser.setCreateTime(date);
List<CouponUserDO> couponUserList = new ArrayList<>();
//系统发放的同一张优惠券如果每人限领数量在多次以上 一次性领取多张
if (CouponConstants.COUPON_ISSUE_TYPE_INITIATIVE.equals(couponDO.getGetType())){
Integer restrictedAccess = couponDO.getRestrictedAccess();
// if (restrictedAccess > 1){
// for (Integer integer = 0; integer < restrictedAccess; integer++) {
// couponUserList.add(couponUser);
// }
// }
for (Integer integer = 0; integer < restrictedAccess; integer++) {
couponUserList.add(couponUser);
}
}else {
couponUserList.add(couponUser);
}
Boolean execute = transactionTemplate.execute(e -> {
this.saveBatch(couponUserList);
//扣减数量
couponBackService.deduction(couponDO.getId(), couponUserList.size(), couponDO.getIsLimited());
return Boolean.TRUE;
});
if (execute) {
asynSendUserAppletMsg(currentAccount.getId(),couponDO) ;
return ResultBody.success();
} else {
return ResultBody.error("领取失败,请稍后再试");
}
}
public void asynSendUserAppletMsg(Integer userId, CouponDO couponDO){
BigDecimal couponMoney = couponDO.getCouponMoney();
MallUserDTO mallUserDTO =null;
// mallUserClient.feignGetSimpleUserInfo(userId);
if(Objects.nonNull(mallUserDTO)){
AppletMsgVO aMsg = new AppletMsgVO();
aMsg.setTouser(mallUserDTO.getOpenId());
aMsg.setTemplate_id(WxMsgTemplete.BOUNTY_ACCOUNT_INFORM);
aMsg.setPage(WxMsgDataConfig.M_ORDER_STATUS_COUPON_DETAILS_PAGE);
// 奖励类型
JSONObject thing1 = new JSONObject();
// 时间
JSONObject time3 = new JSONObject();
time3.put("value", DateUtils.format(new Date()));
// 奖励金额
JSONObject amount2 = new JSONObject();
//备注
JSONObject thing4 = new JSONObject();
//打折券
if (CouponType.DISCOUNT_COUPONS.equals(couponDO.getCouponType())){
//无门槛
// 奖励类型
thing1.put("value", "折扣优惠券奖励");
// 奖励金额
amount2.put("value",null);
// 备注
thing4.put("value",String.format("恭喜，%s折优惠券已到账",couponDO.getCouponDiscount()));
}else if(CouponType.REDUCTION_ROLLS.equals(couponDO.getCouponType())){
//满减
// 奖励类型
thing1.put("value", "满减优惠券奖励");
// 奖励金额
amount2.put("value",null);
// 备注
thing4.put("value",String.format("恭喜，满%s减%s优惠券已到账",couponDO.getMinPrice(),couponDO.getCouponMoney()));
}else if(CouponType.NO_THRESHOLD.equals(couponDO.getCouponType())){
//无门槛
// 奖励类型
thing1.put("value", "奖励到账通知");
amount2.put("value", couponMoney);
// 备注
String format = String.format("恭喜，%s元平台优惠券已到账",couponMoney);
thing4.put("value",format);
}
JSONObject data = new JSONObject();
data.put("thing1", thing1);
data.put("amount2", amount2);
data.put("time3", time3);
data.put("thing4", thing4);
aMsg.setData(data);
// mallUserClient.asynSendUserAppletMsg(aMsg);
}
}
@Override
public ResultBody receiveCouponList(List<Integer> id, BaseAccountDTO currentAccount) {
//批量获取优惠券信息
List<CouponDO> couponDOS = couponBackService.listByIds(id);
Boolean execute = true;
StringBuffer sb = new StringBuffer();
List<Integer> list = new ArrayList<>();
if (couponDOS.size() > 0){
for (CouponDO couponDO : couponDOS) {
//查看优惠券状态 开启并且未删除
if (!couponDO.getCouponStatus() || couponDO.getIsDel()) {
sb.append("优惠券名称:" + couponDO.getCouponName() + "-该优惠券已结束,不可领取;");
list.add(couponDO.getId());
continue;
}
//查看当前优惠券剩余量
if (couponDO.getIsLimited() && couponDO.getLastTotal() < 1) {
sb.append("优惠券名称:" + couponDO.getCouponName() + "-该优惠券当前剩余量不够领取;");
list.add(couponDO.getId());
continue;
}
//查看当前优惠券是否限制每人领取
if (couponDO.getIsLimited()){
LambdaQueryWrapper<CouponUserDO> queryWrap = new LambdaQueryWrapper<>();
queryWrap.eq(CouponUserDO::getUid, currentAccount.getId()).eq(CouponUserDO::getCouponId, couponDO.getId());
long count = this.count(queryWrap);
if (count >= couponDO.getRestrictedAccess()) {
sb.append("优惠券名称:" + couponDO.getCouponName() + "-该优惠券已领取,不可重复领取;");
list.add(couponDO.getId());
continue;
}
}
//优惠券有效期使用时间
Integer couponDay = couponDO.getCouponDay();
DateTime date = DateUtil.date();
if (CouponConstants.COUPON_USE_TIME_THE_DAY.equals(couponDO.getIsFixedTime())) {
//领取当日起
couponDO.setUseStartTime(date);
couponDO.setUseEndTime(DateUtil.offsetDay(date, couponDay));
} else if (CouponConstants.COUPON_USE_TIME_NEXT_DAY.equals(couponDO.getIsFixedTime())) {
//领取次日起
DateTime dateTime = DateUtil.offsetDay(date, 1);
couponDO.setUseStartTime(dateTime);
couponDO.setUseEndTime(DateUtil.offsetDay(dateTime, couponDay));
}
CouponUserDO couponUser = new CouponUserDO(couponDO);
couponUser.setUid(currentAccount.getId());
couponUser.setUuid(currentAccount.getUid());
couponUser.setUserPhone(currentAccount.getAccountPhone());
//如果优惠券是活动券 则为活动领取
if (CouponConstants.COUPON_USR_TYPE_ACTIVITY.equals(couponDO.getGetType())){
couponUser.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_ACTIVITY);
//如果优惠券用户标签不为空 则为系统发放
}else if (couponDO.getUserTag() != null){
couponUser.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_SEND);
} else {
couponUser.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_GET);
}
couponUser.setCreateTime(date);
List<CouponUserDO> couponUserList = new ArrayList<>();
//系统发放的同一张优惠券如果每人限领数量在多次以上 一次性领取多张
if (CouponConstants.COUPON_ISSUE_TYPE_INITIATIVE.equals(couponDO.getGetType())){
Integer restrictedAccess = couponDO.getRestrictedAccess();
for (Integer integer = 0; integer < restrictedAccess; integer++) {
couponUserList.add(couponUser);
}
}else {
couponUserList.add(couponUser);
}
execute = transactionTemplate.execute(e -> {
this.saveBatch(couponUserList);
//扣减数量
couponBackService.deduction(couponDO.getId(), couponUserList.size(), couponDO.getIsLimited());
return Boolean.TRUE;
});
}
}
if (execute) {
List<CouponDO> collect = couponDOS.stream().filter(e -> {
for (Integer integer : list) {
if (integer.equals(e.getId())){
return false;
}
}
return true;
}).collect(Collectors.toList());
System.out.println(collect);
log.info("消息发送成功"+collect);
collect.stream().forEach(t->{
asynSendUserAppletMsgList(currentAccount.getId(),t);
});
return ResultBody.success(sb);
} else {
return ResultBody.error("领取失败,请稍后再试");
}
}
public void asynSendUserAppletMsgList(Integer userId,CouponDO couponDO){
BigDecimal couponMoney = couponDO.getCouponMoney();
MallUserDTO mallUserDTO =null;
//mallUserClient.feignGetSimpleUserInfo(userId);
if(Objects.nonNull(mallUserDTO)){
AppletMsgVO aMsg = new AppletMsgVO();
aMsg.setTouser(mallUserDTO.getOpenId());
aMsg.setTemplate_id(WxMsgTemplete.BOUNTY_ACCOUNT_INFORM);
aMsg.setPage(WxMsgDataConfig.M_ORDER_STATUS_COUPON_DETAILS_PAGE);
// 奖励类型
JSONObject thing1 = new JSONObject();
// 时间
JSONObject time3 = new JSONObject();
time3.put("value", DateUtils.format(new Date()));
// 奖励金额
JSONObject amount2 = new JSONObject();
//备注
JSONObject thing4 = new JSONObject();
//打折券
if (CouponType.DISCOUNT_COUPONS.equals(couponDO.getCouponType())){
//打折券
// 奖励类型
thing1.put("value", "折扣优惠券奖励");
// 奖励金额
amount2.put("value",null);
// 备注
thing4.put("value",String.format("恭喜，%s折优惠券已到账",couponDO.getCouponDiscount()));
}else if(CouponType.REDUCTION_ROLLS.equals(couponDO.getCouponType())){
//满减
// 奖励类型
thing1.put("value", "满减优惠券奖励");
// 奖励金额
amount2.put("value",null);
// 备注
thing4.put("value",String.format("恭喜，满%s减%s优惠券已到账",couponDO.getMinPrice(),couponDO.getCouponMoney()));
}else if(CouponType.NO_THRESHOLD.equals(couponDO.getCouponType())){
//无门槛
// 奖励类型
thing1.put("value", "奖励到账通知");
amount2.put("value", couponMoney);
// 备注
String format = String.format("恭喜，%s元平台优惠券已到账",couponMoney);
thing4.put("value",format);
}
JSONObject data = new JSONObject();
data.put("thing1", thing1);
data.put("amount2", amount2);
data.put("time3", time3);
data.put("thing4", thing4);
aMsg.setData(data);
// mallUserClient.asynSendUserAppletMsg(aMsg);
}
}
@Override
public ResultBody presentedCoupon(Integer id, String uid,BaseAccountDTO currentAccount) {
CouponUserDO couponUser = getById(id);
if (couponUser == null) {
return ResultBody.error("该优惠券不存在");
}
if (CouponConstants.STORE_COUPON_USER_STATUS_USED.equals(couponUser.getStatus()) ||
CouponConstants.STORE_COUPON_USER_STATUS_IN_USE.equals(couponUser.getStatus())){
return ResultBody.error("该优惠券已使用不能转赠");
}
if (CouponConstants.STORE_COUPON_USER_TYPE_ACTIVITY.equals(couponUser.getGainType())){
return ResultBody.error("该优惠券不能转赠");
}
String uuid = "UID" + uid;
PageResult<List<MallUserDTO>> listPageResult =null;
// mallUserClient.feignMallUserBySearchKey(uuid, 1, 10);
if (listPageResult != null && listPageResult.getList() != null) {
List<MallUserDTO> list = listPageResult.getList();
MallUserDTO mallUserDTO = list.get(0);
CouponUserDO couponUserDO = new CouponUserDO();
BeanUtils.copyProperties(couponUser, couponUserDO);
//修改原用户数据
couponUser.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_PRESENTED);
couponUser.setStatus(CouponConstants.STORE_COUPON_USER_STATUS_PRESENTED);
couponUser.setCreateTime(new Date());
couponUser.setReceiveUid(uuid);
couponUser.setTransferorTime(new Date());
//修改获赠用户优惠券数据
couponUserDO.setId(null);
couponUserDO.setUid(mallUserDTO.getId());
couponUserDO.setUuid(mallUserDTO.getUid());
couponUserDO.setUserPhone(mallUserDTO.getPhoneNum());
couponUserDO.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_ACQUIRE);
couponUserDO.setCreateTime(new Date());
couponUserDO.setTransferorUid(currentAccount.getUid());
Boolean execute = transactionTemplate.execute(e -> {
this.save(couponUserDO);
this.updateById(couponUser);
return Boolean.TRUE;
});
if (execute) {
Integer useType = couponUser.getUseType();
if (VIPCOUPON.equals(useType)){
asynSendMessage(couponUser.getUid(),couponUser.getCouponMoney());
}
return ResultBody.success();
} else {
return ResultBody.error("转增失败,请稍后再试");
}
} else {
return ResultBody.error("该用户不存在");
}
}
public void asynSendMessage(Integer userId, BigDecimal couponMoney){
MallUserDTO mallUserDTO =null;
//mallUserClient.feignGetSimpleUserInfo(userId);
if(Objects.nonNull(mallUserDTO)){
WxSendMsgVO param = new WxSendMsgVO();
param.setWxAppltAppId(FlyerSystemConstant.AppletFlyerWxAppid);
// 对接
param.setAppletPath("page-activity/discount-list/index");
param.setUnionId(mallUserDTO.getUnionId());
// 获取模板id
param.setTemplemteId(WxMsgTemplete.BOUNTY_ACCOUNT_INFORM);
MsgData title = new MsgData();
title.setValue("无人机城好友转赠优惠券");
param.setTitle(title);
List<MsgData> data = new ArrayList<MsgData>();
MsgData k1 = new MsgData();
k1.setValue("VIP优惠券");
data.add(k1);
MsgData k2 = new MsgData();
k2.setValue(couponMoney+"");
data.add(k2);
MsgData k3 = new MsgData();
k3.setValue(TDateUtil.getCurrentDate());
data.add(k3);
MsgData k4 = new MsgData();
String format = String.format("恭喜，好友赠送%s元VIP优惠券已到账",couponMoney);
k4.setValue(format);
data.add(k4);
param.setData(data);
// param.setRemark(remark);
// userServletClient.asynSendMessage(param);
}
}
@Override
public ResultBody getList( List<Integer> priority,Integer pageNo,Integer pageSize, BaseAccountDTO currentAccount) {
String date = DateUtil.now();
String categoryIdStr = priority.stream().map(Object::toString).collect(Collectors.joining("|"));
StringBuffer sb = new StringBuffer();
sb.append(",(").append(categoryIdStr).append(")");
//目前只有 品牌优惠券可以主动领取
Integer pageParam = (pageNo - 1) * pageSize;
List<CouponDO> records = couponBackDao.selectCouponList(date, sb.toString(), pageParam, pageSize);
Integer integer = couponBackDao.selectCouponCount(date, sb.toString());
//获取用户当前已领取未使用的优惠券
HashMap<Integer, CouponUserDO> couponUserMap = new HashMap<>();
Integer userId = currentAccount.getId();
LambdaQueryWrapper<CouponUserDO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(CouponUserDO::getUid, userId);
List<CouponUserDO> list = this.list(lambdaQueryWrapper);
for (CouponUserDO couponUserDO : list) {
couponUserMap.put(couponUserDO.getCouponId(), couponUserDO);
}
List<CouponListDTO> couponFrontResponseArrayList = new ArrayList<>();
for (CouponDO coupon : records) {
CouponListDTO couponListDTO = coupon.bilIdCouponListDTO();
if (userId > 0) {
if (CollUtil.isNotEmpty(couponUserMap) && couponUserMap.containsKey(coupon.getId())) {
couponListDTO.setIsUse(true);
LambdaQueryWrapper<CouponUserDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CouponUserDO::getUid, userId);
queryWrapper.eq(CouponUserDO::getCouponId,coupon.getId());
int count = Math.toIntExact(this.count(queryWrapper));
couponListDTO.setReceivedCount(count);
}
}
couponFrontResponseArrayList.add(couponListDTO);
}
PageResult pageResult = PageResult.buildPage(pageNo, pageSize, integer, couponFrontResponseArrayList);
return ResultBody.success(pageResult);
}
@Override
public List<CouponUserOrderDTO> getUsableCoupon(List<Integer> primaryKey,Integer uid) {
String categoryIdStr = primaryKey.stream().map(Object::toString).collect(Collectors.joining("|"));
String date = DateUtil.now();
StringBuffer sb = new StringBuffer();
sb.append(",(").append(categoryIdStr).append(")");
//可用优惠券
List<CouponUserDO> couponUserDOS = couponUserDao.selectCouponUserList(sb.toString(),uid, date);
List<CouponUserOrderDTO> collect = couponUserDOS.stream().map(CouponUserDO::buildCouponUserOrderDTO)
.collect(Collectors.toList());
//用户全部优惠券
LambdaQueryWrapper<CouponUserDO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(CouponUserDO::getUid, uid);
lambdaQueryWrapper.ge(CouponUserDO::getEndTime, new Date());
lambdaQueryWrapper.and(i -> i.eq(CouponUserDO::getStatus, CouponConstants.STORE_COUPON_USER_STATUS_USABLE)
.or().eq(CouponUserDO::getStatus,CouponConstants.STORE_COUPON_USER_STATUS_IN_USE));
List<CouponUserDO> list = this.list(lambdaQueryWrapper);
List<CouponUserOrderDTO> disable = list.stream().map(CouponUserDO::buildCouponUserOrderDTO)
.collect(Collectors.toList());
for (CouponUserOrderDTO couponUserOrderDTO : collect) {
for (CouponUserOrderDTO userOrderDTO : disable) {
if (couponUserOrderDTO.getId().equals(userOrderDTO.getId())){
userOrderDTO.setValidStr("usable");
}
}
}
return disable;
}
@Override
public List<CouponUserDTO> feignGetById(List<Integer> couponId) {
List<CouponUserDO> couponUserDOS = this.listByIds(couponId);
return couponUserDOS.stream().map(CouponUserDO::bilIdCouponDTO).collect(Collectors.toList());
}
@Override
public Boolean feignUpMyCoupon(List<CouponUserVO> couponUserVO) {
Boolean updateById = true;
for (CouponUserVO userVO : couponUserVO) {
userVO.setOrderUsageTime(new Date());
CouponUserDO couponUserDO = new CouponUserDO(userVO);
couponUserDO.setUseTime(new Date());
Boolean execute = transactionTemplate.execute(e -> {
couponUserDao.insertCouponUserOrder(userVO);
this.updateById(couponUserDO);
return Boolean.TRUE;
});
if (!execute){
updateById = false;
}
}
return updateById;
}
@Override
public Boolean feignExchangeCoupon(CouponUserExchangeVO couponUserExchangeVO) {
DateTime date = DateUtil.date();
CouponUserDO couponUserDO = new CouponUserDO(couponUserExchangeVO);
couponUserDO.setCouponType(CouponConstants.COUPON_TYPE_NO_THRESHOLD);
couponUserDO.setUseType(CouponConstants.COUPON_USR_TYPE_VIP);
couponUserDO.setGainType(CouponConstants.STORE_COUPON_USER_TYPE_EXCHANGE);
couponUserDO.setStatus(CouponConstants.STORE_COUPON_USER_STATUS_USABLE);
couponUserDO.setStartTime(date);
//兑换vip卷过期时间=+50年
DateTime dateTime = DateUtil.offset(date, DateField.YEAR,50);
couponUserDO.setEndTime(dateTime);
couponUserDO.setCreateTime(date);
return this.save(couponUserDO);
}
@Override
public void overdueTask() {
// 查询所有状态——可用的优惠券
LambdaQueryWrapper<CouponUserDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(CouponUserDO::getStatus, CouponConstants.STORE_COUPON_USER_STATUS_USABLE);
List<CouponUserDO> list = this.list(queryWrapper);
if (CollUtil.isEmpty(list)){
return;
}
List<CouponUserDO> updateList = CollUtil.newArrayList();
list.forEach(coupon -> {
if (ObjectUtil.isNotNull(coupon.getEndTime())) {
if (DateUtil.date().after(coupon.getEndTime())) {
coupon.setStatus(2);
updateList.add(coupon);
}
}
});
if (CollUtil.isEmpty(updateList)){
return;
}
boolean update = this.updateBatchById(updateList);
if (!update){
log.error("批量更新优惠券过期动作失败");
}
}
@Override
public List<CouponUserOrderDTO> feignListUserCouponsByIds(List<Integer> couponIds) {
List<CouponUserDO> couponUserDOS = couponUserDao.selectBatchIds(couponIds);
List<CouponUserOrderDTO> collect = couponUserDOS.stream().map(d -> d.buildCouponUserOrderDTO()).collect(Collectors.toList());
return collect;
}
@Override
public List<CouponUserDTO> feignOrderCoupon(String orderNumber) {
CouponUserInfoQO couponUserInfoQO = new CouponUserInfoQO();
couponUserInfoQO.setOrderNumber(orderNumber);
couponUserInfoQO.setPageNo(0);
couponUserInfoQO.setPageSize(99);
List<CouponUserDTO> couponUserDTOS = couponUserDao.selectCouponUserInfoList(couponUserInfoQO);
return couponUserDTOS;
}
@Override
public Boolean feignRollbackCoupons(List<OrderCouponDTO> orderCouponDTOS) {
log.info("feignRollbackCoupons优惠券回滚：{}", JSONObject.toJSON(orderCouponDTOS));
Set<Long> orderIds = orderCouponDTOS.stream().map(d -> d.getOrderId()).collect(Collectors.toSet());
List<Integer> ids = orderCouponDTOS.stream().map(d->d.getCouponUserId()).collect(Collectors.toList());
List<CouponUserDO> couponUserDOS = couponUserDao.selectBatchIds(ids);
//批量删除该订单相关优惠券
couponUserDao.batchRemoveByOIds(orderIds);
couponUserDOS.forEach(d->{
if (d.getUseType().equals(1) || (d.getUseType().equals(2) && d.getCouponType().equals(3)) ){
//vip和无门槛券
if (d.getVerificationType() == null || d.getVerificationType().equals(true)){
//多次核销
for (OrderCouponDTO couponDTO : orderCouponDTOS) {
if (d.getId().toString().equals(couponDTO.getCouponUserId().toString())){
d.setStatus(4);
d.setRemainingBalance(d.getRemainingBalance() == null ? couponDTO.getUseAmount() : d.getRemainingBalance().add(couponDTO.getUseAmount()));
break;
}
}
}else {
//单次核销
d.setStatus(0);
d.setRemainingBalance(d.getCouponMoney());
d.setUseTime(null);
}
}else {
//满减和折扣
d.setStatus(0);
d.setUseTime(null);
}
couponUserDao.updateById(d);
});
return true;
}
@Override
public ResultBody couponMerchandise(Integer couponId,String productName,Integer useType) {
List<AppGoodsInfoDTO> collect =null;
List<GoodsInfoDO> goodsInfoDos=null;
if (VIPCOUPON.equals(useType)){
goodsInfoDos = couponUserDao.VipCouponMerchandise(productName);
}else if(BRAND_COUPONS.equals(useType)){
List<Integer> merchandise = couponUserDao.merchandise(couponId);
if (merchandise.size()==0){
return ResultBody.error("当前优惠券没有关联的商品");
}
goodsInfoDos = couponUserDao.couponMerchandise(merchandise,productName);
}
collect = goodsInfoDos.stream().map(GoodsInfoDO::buildAppGoodsInfoDTO).collect(Collectors.toList());
return ResultBody.success(collect);
}
@Override
public ResultBody couponUsageDetails(Integer uid){
List<CouponUsageDetailsDO> couponUsageDetailsDOS = couponUserDao.couponUsageDetails(uid);
List<CouponUsageDetailsDTO> collect = couponUsageDetailsDOS.stream().map(CouponUsageDetailsDO::bilIdCouponUsageDetailsDTO).collect(Collectors.toList());
return ResultBody.success(collect);
}
}
src/main/java/com/mmc/oms/wx/WxMsgTemplete.java 0 → 100644
package com.mmc.oms.wx;
/**
* @Author small
* @Date 2023/5/24 16:10
* @Version 1.0
*/
public class WxMsgTemplete {
/**
* 企业认证结果-通知-服务号
*/
public static final String FW_ENTERPRICE_RESULT = "aGGeglB3qYpjDhqE3iIli6DllF5d99dVqbEcRfUq2NA";
/**
* 渠道申请结果-通知-服务号
*/
public static final String FW_CHANNEL_RESULT = "sF0of_i6wFdMNKn-XBDTKX6r7HwcLX6ZtnCuSat-wgU";
/**
* 订单分配成功-通知-服务号
*/
public static final String FW_ORDER_OPERATE = "2ky9Iu3_yoz0feH_4zswZCmWQM2hAhsQljZs8OyAsXc";
/**
* 渠道商申请-通知-小程序
*/
public static final String AT_CHANNEL = "1ucObCkquUVK5NnxLjC4FFda4_5Z8Uuyv3yHRlKjILY";
/**
* 订单支付-通知-小程序
*/
public static final String AT_ORDER_PAY = "nxyGPOeNrceP_UlK2rw0c_1_Ewn3IRWyMUn-rDPAYh0";
/**
* 订单取消-通知-小程序
*/
public static final String AT_ORDER_CANCEL = "jvachbP1FBpVbXxljMYqdLKNiWHqqXAE1vX-9iLRL90";
/**
* 需求确认-通知-小程序
*/
public static final String AT_ORDER_XUQIU_CONFIRM = "0UFAFyX7Ko7Fj8MYbgGAbPNAoJzjUK1ZWluAdP3Lp1M";
/**
* 平台确认需求-通知-小程序
*/
public static final String AT_PLATFORM_CONFIRM_ORDER = "3RX0Bhw0cUDCtw3nrMaEV-eQ2BHuiJXEjGfNmaa_EEo";
/**
* 订单确认-通知-小程序
*/
public static final String AT_ORDER_CONFIRM = "0UFAFyX7Ko7Fj8MYbgGAbONiupPZ9KQGIWwCeYITliw";
/**
* 实名认证-通知-小程序
*/
public static final String AT_REAL_NAME_CONFIRM = "naeIe3C40syWbkGr2w1OtViMh4ILfoZW10H4E65HRXQ";
/**
* 企业认证-通知-小程序
*/
public static final String AT_ENT_AUTH_CONFIRM = "yuoAsC8OmM05LgshZE8EwHzvelA3xJAjNfqVciYCZm0";
/**
* 订单结算-通知-小程序
*/
public static final String AT_ORDER_FINISH = "ftH61r04ahPUEDffIObCSY5_rEBIkVOSgwEw9cjgJ34";
/**
* 提现结果-通知-小程序
*/
public static final String AT_REBATE_FINISH = "qPP6yd-0pC9e5vwg1_W19eQoKj1L70kyGXlfw1OTJrM";
/**
* 指派飞手-通知-服务号
*/
public static final String FW_ASSIGN_FLYER = "2ky9Iu3_yoz0feH_4zswZCmWQM2hAhsQljZs8OyAsXc";
/**
* 审核飞手电子执照
*/
public static final String FW_CHECK_FLYER_AUTH_INFO = "sF0of_i6wFdMNKn-XBDTKX6r7HwcLX6ZtnCuSat-wgU";
/**
* 云仓提现结果-通知-小程序
*/
public static final String AT_REPO_REBATE_FINISH = "aDYlzHMIxakuUu3cAEvydjpMzDWKhZhE0FtrtuKBLoE";
/**
* 云飞手提现结果-通知-小程序
*/
public static final String AT_FLYER_REBATE_FINISH = "-xfYvIJUhUb9NsvAVKdC54zRvTy4_zWrHZ-E8NtOCM8";
/**
* 云仓待支付-通知-小程序
*/
public static final String AT_REPO_TO_BE_PAID = "cgNbjkiqdu-_792njhIBHPI9biuRbhECnN-eB9aoI5E";
/**
* 云仓发货-通知-小程序
*/
public static final String AT_REPO_SHIP = "vACKjBo5ehOt5hvL0emaqJCh6DE14bX5Vb5fXZNXfkg";
/**
* 云仓渠道审核通过-通知-小程序
*/
public static final String AT_CHANNEL_PASS = "r4BMrsaadSFhfft02t2lmOsu7MwCtijF-pvoJvsoyT8";
/**
* 云享飞平台催单-通知-小程序
*/
public static final String URGE_PAYMENT = "TBLzdom8B_FyGlajWAMYaen6lHymrUwtkCdARKEiSLs";
/**
* 云飞手抢单失败-通知-小程序
*/
public static final String FLYER_APPLY_ORDER_FAILED = "Nb0VctO8LCew9B9erWfy7J3C8CI7JkFwEHE2ie13qgg";
/**
* 无人机城订单状态变更-通知-小程序
*/
public static final String MALL_ORDER_STATUS_CHANGE = "9t_5kHO3NbqqA5OEDNZgnltVECjnyoj9mBPPP6-sf2M";
/**
* 无人机城奖励金到账通知
*/
public static final String BOUNTY_ACCOUNT_INFORM = "ZmqEVoL98HMGkFw1sYjYr92-_BdFh_-XhyoIMV5t07U";
/**
* 公众号——优惠券到账通知
*/
public static final String COUPON_RECEIPT_NOTICE = "j30Yp4qPs_fjb00U0BLw1vQ_5jsafCPX88a9A9SYVkI";
}
src/main/resources/application-dev.yml
......@@ -14,6 +14,9 @@ spring:
pool:
max-active: 2
main:
allow-circular-references: true
springfox:
documentation:
swagger-ui:
......@@ -33,4 +36,20 @@ mmcflying:
mount:
directory: D:@javaVolume@
#公众号推送消息
wechat:
sub:
appid: wx5c6a105a0ddca4c5
secret: 96c75255dd26f82f8d55e15b59e101c7
applet:
appid: wx3121a147f65f1900
secret: 94296481fdad89c251892b9b722f3c73
miniprogram-state: trial
rabbitmq:
exchange: FLYER_WX_API_DIRECT_DEV
workFlyerInfoKey: TEST_WORK_FLYER_INFO
src/main/resources/application-local.yml
......@@ -13,6 +13,8 @@ spring:
jedis:
pool:
max-active: 2
main:
allow-circular-references: true
springfox:
documentation:
......@@ -33,4 +35,19 @@ mmcflying:
mount:
directory: D:@javaVolume@
#公众号推送消息
wechat:
sub:
appid: wx5c6a105a0ddca4c5
secret: 96c75255dd26f82f8d55e15b59e101c7
applet:
appid: wx3121a147f65f1900
secret: 94296481fdad89c251892b9b722f3c73
miniprogram-state: trial
rabbitmq:
exchange: FLYER_WX_API_DIRECT_DEV
workFlyerInfoKey: TEST_WORK_FLYER_INFO
src/main/resources/application-prod.yml
......@@ -13,6 +13,8 @@ spring:
jedis:
pool:
max-active: 2
main:
allow-circular-references: true
springfox:
documentation:
......@@ -32,3 +34,18 @@ mmcflying:
path: /ossservlet/upload/download/
mount:
directory: D:@javaVolume@
#公众号推送消息
wechat:
sub:
appid: wx5c6a105a0ddca4c5
secret: 96c75255dd26f82f8d55e15b59e101c7
applet:
appid: wx3121a147f65f1900
secret: 94296481fdad89c251892b9b722f3c73
miniprogram-state: trial
rabbitmq:
exchange: FLYER_WX_API_DIRECT_DEV
workFlyerInfoKey: TEST_WORK_FLYER_INFO
src/main/resources/mapper/CouponBackDao.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mmc.oms.dao.CouponBackDao">
<select id="selectCouponList" resultType="com.mmc.oms.entity.CouponDO">
SELECT
id,
coupon_name,
coupon_money,
coupon_discount,
is_limited,
restricted_access,
coupon_total,
last_total,
coupon_type,
use_type,
min_price,
primary_key,
is_fixed_time,
use_start_time,
use_end_time,
coupon_day,
get_type,
user_tag,
coupon_status,
is_del,
create_time,
update_time,
preferential_limit,
verification_type
FROM
coupon
WHERE
is_del = false
AND
coupon_status = true
AND
(last_total > 0 OR is_limited = false)
AND
(use_end_time IS NULL OR (use_end_time &gt; #{date}))
AND
get_type = 1
AND
use_type = 2
<if test="priority != null and priority !=''">
AND CONCAT(',',primary_key,',') REGEXP #{priority}
</if>
order by create_time desc
limit #{pageNo},#{pageSize}
</select>
<select id="selectCouponCount" resultType="java.lang.Integer">
SELECT
count(*)
FROM
coupon
WHERE
is_del = false
AND
coupon_status = true
AND
(last_total > 0 OR is_limited = false)
AND
(use_end_time IS NULL OR (use_end_time &gt; #{date}))
AND
get_type = 1
AND
use_type = 2
<if test="priority != null and priority !=''">
AND CONCAT(',',primary_key,',') REGEXP #{priority}
</if>
</select>
<select id="fissionActivity" resultType="com.mmc.oms.entity.CouponDO">
SELECT DISTINCT
substring_index( substring_index( a.primary_key, ',', b.help_topic_id + 1 ), ',',- 1 ) primaryKey,
a.id,
a.coupon_name AS couponName,
a.get_type,
a.coupon_money AS couponMoney,
a.coupon_discount AS couponDiscount,
a.is_limited AS isLimited,
a.restricted_access AS restrictedAccess,
a.coupon_total AS couponTotal,
a.last_total AS lastTotal,
a.coupon_type AS couponType,
a.use_type AS useType,
a.min_price AS minPrice,
a.is_fixed_time AS isFixedTime,
a.use_start_time AS useStartTime,
a.use_end_time AS useEndTime,
a.coupon_day AS couponDay,
a.get_type AS getType,
a.user_tag AS userTag,
a.coupon_status AS couponStatus,
a.is_del AS isDel,
a.preferential_limit AS preferentialLimit,
a.verification_type AS verificationType,
a.create_time AS createTime,
a.update_time AS updateTime,
a.parent_id AS parentId,
a.people_number AS peopleNumber,
a.file_url AS fileUrl,
CASE WHEN a.coupon_total - a.last_total IS NULL THEN
0 ELSE a.coupon_total - a.last_total
END quantityClaimed
FROM
coupon a
JOIN mysql.help_topic b ON b.help_topic_id &lt; ( length( a.primary_key ) - length( REPLACE ( a.primary_key, ',', '' ) ) + 1 )
WHERE
a.is_del = 0
AND a.get_type = 4
AND a.primary_key = #{brandId}
</select>
<select id="ordinaryActivities" resultType="com.mmc.oms.entity.CouponDO">
SELECT DISTINCT
substring_index( substring_index( a.primary_key, ',', b.help_topic_id + 1 ), ',',- 1 ) primaryKey,
a.id,
a.coupon_name AS couponName,
a.get_type,
a.coupon_money AS couponMoney,
a.coupon_discount AS couponDiscount,
a.is_limited AS isLimited,
a.restricted_access AS restrictedAccess,
a.coupon_total AS couponTotal,
a.last_total AS lastTotal,
a.coupon_type AS couponType,
a.use_type AS useType,
a.min_price AS minPrice,
a.is_fixed_time AS isFixedTime,
a.use_start_time AS useStartTime,
a.use_end_time AS useEndTime,
a.coupon_day AS couponDay,
a.get_type AS getType,
a.user_tag AS userTag,
a.coupon_status AS couponStatus,
a.is_del AS isDel,
a.preferential_limit AS preferentialLimit,
a.verification_type AS verificationType,
a.create_time AS createTime,
a.update_time AS updateTime,
a.parent_id AS parentId,
a.people_number AS peopleNumber,
a.file_url AS fileUrl,
CASE WHEN a.coupon_total - a.last_total IS NULL THEN
0 ELSE a.coupon_total - a.last_total
END quantityClaimed
FROM
coupon a
JOIN mysql.help_topic b ON b.help_topic_id &lt; ( length( a.primary_key ) - length( REPLACE ( a.primary_key, ',', '' ) ) + 1 )
WHERE
a.is_del = 0
AND a.get_type IN ( 1, 2, 3 )
AND a.primary_key = #{brandId}
</select>
<select id="findProduct" resultType="com.mmc.oms.entity.ProductInformationDo">
SELECT
gi.id AS goodsInfoId,
gi.goods_name AS goodsName,
mpsi.prod_sku_spec_name AS prodSkuSpecName,
ps.id AS productSkuId,
ps.product_name AS productName,
bi.id AS brandId,
bi.brand_name AS brandName
FROM
uav_mall_goods.goods_info gi
INNER JOIN uav_mall_goods.mall_prod_sku_info mpsi ON mpsi.goods_info_id = gi.id
INNER JOIN uav_mall_goods.product_sku ps ON mpsi.prod_sku_id = ps.id and ps.is_deleted=0
INNER JOIN uav_mall_goods.brand_info bi ON ps.brand_info_id = bi.id and bi.is_delete=0
WHERE
gi.is_deleted=0
and gi.id = #{goodsInfoId}
</select>
</mapper>
src/main/resources/mapper/CouponUserDao.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mmc.oms.dao.CouponUserDao">
<update id="batchRemoveByOIds">
update coupon_user_order set is_del = 1
where order_id in
<foreach collection="orderIds" item="orderId" open="(" close=")" separator=",">
#{orderId}
</foreach>
</update>
<select id="selectCouponUserList" resultType="com.mmc.oms.entity.CouponUserDO">
SELECT
id,
coupon_id,
uid,
user_phone,
coupon_name,
coupon_type,
use_type,
coupon_money,
min_price,
coupon_discount,
remaining_balance,
gain_type,
status,
create_time,
update_time,
start_time,
end_time,
use_time,
primary_key,
conversion_ratio,
transferor_uid,
receive_uid,
transferor_time,
preferential_limit,
verification_type
FROM
coupon_user
WHERE
(status = 0 or status = 4)
AND
start_time &lt; #{data}
AND
end_time &gt; #{data}
AND
uid = #{uid}
AND
(use_type = 1
OR
((use_type = 2) AND CONCAT(',',primary_key,',') REGEXP #{list} ))
</select>
<select id="selectCouponUserInfoList" resultType="com.mmc.oms.model.dto.CouponUserDTO">
SELECT
cu.id,
cu.coupon_id,
cu.uid,
cu.uuid,
cu.user_phone,
cu.coupon_name,
cu.coupon_type,
cu.use_type,
cu.coupon_money,
cu.min_price,
cu.coupon_discount,
cu.remaining_balance,
cu.gain_type,
cu.status,
cu.create_time,
cu.update_time,
cu.start_time,
cu.end_time,
cu.use_time,
cu.primary_key,
cu.conversion_ratio,
cu.transferor_uid,
cu.receive_uid,
cu.transferor_time,
cu.preferential_limit,
cu.verification_type,
cuo.order_id AS cid,
cuo.order_no
FROM
coupon_user cu
LEFT JOIN
coupon_user_order cuo on cu.id = cuo.coupon_user_id
AND cuo.is_del = false
WHERE
1=1
<if test="uid != null and uid !=''">
AND cu.uuid like CONCAT('%',#{uid},'%')
</if>
<if test="userPhone != null and userPhone !=''">
AND cu.user_phone like CONCAT('%',#{userPhone},'%')
</if>
<if test="couponId != null and couponId !=''">
AND cu.coupon_id like CONCAT('%',#{couponId},'%')
</if>
<if test="orderNumber != null and orderNumber !=''">
AND cuo.order_no like CONCAT('%',#{orderNumber},'%')
</if>
<if test="gainType != null and gainType !=''">
AND cu.gain_type =#{gainType}
</if>
<if test="state != null">
AND cu.status =#{state}
</if>
<if test="useTime != null and useTime !=''">
AND date_format(cu.use_time,'%Y-%m-%d') = #{useTime}
</if>
<if test="createTime != null and createTime !=''">
AND date_format(cu.create_time,'%Y-%m-%d') = #{createTime}
</if>
ORDER BY
cu.create_time desc
LIMIT #{pageNo},#{pageSize}
</select>
<select id="selectCouponUserInfoCount" resultType="java.lang.Integer">
SELECT
COUNT(*)
FROM
coupon_user cu
LEFT JOIN
coupon_user_order cuo on cu.id = cuo.coupon_user_id
AND cuo.is_del = false
WHERE
1 = 1
<if test="uid != null and uid !=''">
AND cu.uuid like CONCAT('%',#{uid},'%')
</if>
<if test="userPhone != null and userPhone !=''">
AND cu.user_phone like CONCAT('%',#{userPhone},'%')
</if>
<if test="couponId != null and couponId !=''">
AND cu.coupon_id like CONCAT('%',#{couponId},'%')
</if>
<if test="orderNumber != null and orderNumber !=''">
AND cuo.order_no like CONCAT('%',#{orderNumber},'%')
</if>
<if test="gainType != null and gainType !=''">
AND cu.gain_type =#{gainType}
</if>
<if test="state != null">
AND cu.status =#{state}
</if>
<if test="useTime != null and useTime !=''">
AND date_format(cu.use_time,'%Y-%m-%d') = #{useTime}
</if>
<if test="createTime != null and createTime !=''">
AND date_format(cu.create_time,'%Y-%m-%d') = #{createTime}
</if>
</select>
<insert id="insertCouponUserOrder" keyProperty="id" useGeneratedKeys="true">
insert into coupon_user_order(coupon_user_id, order_id, order_no,remaining_balance,use_amount,order_usage_time)
values (#{id}, #{cid}, #{orderNo},#{remainingBalance},#{useAmount},#{orderUsageTime})
</insert>
<select id="getOrderList" resultType="java.lang.Long">
SELECT
cuo.order_id
FROM
coupon_user_order cuo
LEFT JOIN
coupon_user cu on cuo.coupon_user_id = cu.id
WHERE
cuo.is_del = false
AND
cu.coupon_id = #{id}
</select>
<select id="merchandise" resultType="java.lang.Integer" parameterType="java.lang.Integer">
SELECT DISTINCT
substring_index( substring_index( a.primary_key, ',', b.help_topic_id + 1 ), ',',- 1 ) primaryKey
FROM
coupon a
JOIN mysql.help_topic b ON b.help_topic_id &lt; ( length( a.primary_key ) - length( REPLACE ( a.primary_key, ',', '' ) ) + 1 )
WHERE
a.is_del = 0
AND a.id = #{couponId}
</select>
<select id="couponMerchandise" resultType="com.mmc.oms.entity.GoodsInfoDO">
SELECT
gi.id,
gi.is_deleted,
gi.goods_name AS goodsName,
gi.shelf_status AS shelfStatus,
gim.img_url AS mainImg,
gd.goods_desc AS goodsDesc,
gi.goods_attr AS goodsAttr,
gi.eco_label AS ecoLabel,
gi.is_show_code AS `code`,
gi.sort AS sort,
gi.is_show_code AS showCode,
mpsi.prod_sku_spec_name AS prodSkuSpecName,
ps.id AS productSkuId,
ps.product_name AS productName,
bi.id AS brandId,
bi.brand_name AS brandName
FROM
uav_mall_goods.brand_info bi
INNER JOIN uav_mall_goods.product_sku ps ON ps.brand_info_id = bi.id
AND ps.is_deleted = 0
INNER JOIN uav_mall_goods.mall_prod_sku_info mpsi ON mpsi.prod_sku_id = ps.id
INNER JOIN uav_mall_goods.goods_info gi ON mpsi.goods_info_id = gi.id
AND gi.is_deleted = 0
INNER JOIN uav_mall_goods.goods_img gim ON gi.id = gim.goods_info_id
AND gim.is_deleted = 0
INNER JOIN uav_mall_goods.goods_detail gd ON gd.goods_info_id = gi.id
WHERE
bi.is_delete = 0
AND bi.id in
<foreach collection="merchandise" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
<if test="productName!=null and productName!=''">
and gi.goods_name like concat(concat("%",#{productName}),"%")
</if>
</select>
<select id="VipCouponMerchandise" resultType="com.mmc.oms.entity.GoodsInfoDO">
SELECT
gi.id,
gi.is_deleted,
gi.goods_name AS goodsName,
gi.shelf_status AS shelfStatus,
gim.img_url AS mainImg,
gi.goods_attr AS goodsAttr,
gi.eco_label AS ecoLabel,
gi.is_show_code AS `code`,
gi.sort AS sort,
gi.is_show_code AS showCode,
gd.goods_desc AS goodsDesc
FROM
uav_mall_goods.goods_info gi
INNER JOIN uav_mall_goods.goods_img gim ON gi.id = gim.goods_info_id
AND gim.is_deleted = 0
INNER JOIN uav_mall_goods.goods_detail gd ON gd.goods_info_id = gi.id
WHERE
gi.is_deleted = 0
<if test="productName!=null and productName!=''">
and gi.goods_name like concat(concat("%",#{productName}),"%")
</if>
</select>
<select id="couponUsageDetails" resultType="com.mmc.oms.entity.CouponUsageDetailsDO">
SELECT DISTINCT
cuo.id,
cu.coupon_id AS couponId,
cu.uid,
cu.start_time AS startTime,
cu.coupon_name AS couponName,
cu.`status`,
cu.verification_type AS verificationType,
cuo.coupon_user_id AS couponUserId,
cuo.order_id AS orderId,
cuo.order_no AS orderNo,
cuo.remaining_balance AS remainingBalance,
cuo.use_amount AS useAmount,
cuo.order_usage_time AS orderUsageTime
FROM
coupon_user cu,
coupon_user_order cuo
WHERE
cuo.coupon_user_id = cu.id
AND cu.coupon_type = 3
AND cu.verification_type = 1
AND cu.`status` = 1
AND cu.uid = #{uid}
</select>
</mapper>
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论