Skip to content

P
payment
提交 f80a66c8 作者: 余乾开
操作

Merge branch 'release/0.0.529-1540'

上级 ba9d6588 4e1677df
正在显示 包含 6181 行增加 和 5 行删除
.github/workflows/develop.yml 0 → 100644
name: Build and Push to ACR
on:
push:
branches: [ "develop" ]
env:
REGION_ID: cn-shenzhen
REGISTRY: mmc-registry.cn-shenzhen.cr.aliyuncs.com
NAMESPACE: sharefly-dev
IMAGE: payment
TAG: ${{ github.sha }}
ACR_EE_REGISTRY: mmc-registry.cn-shenzhen.cr.aliyuncs.com
ACR_EE_INSTANCE_ID: cri-yhk5zgfc2v1sia6l
ACR_EE_NAMESPACE: sharefly-dev
ACR_EE_IMAGE: payment
ACR_EE_TAG: ${{ github.sha }}
JAVA_VERSION: '8'
GITLAB_URL: https://oauth2:MjVJKxB7m4tCy7symBzn@git.mmcuav.cn/iuav/payment.git
permissions:
contents: read
jobs:
build:
runs-on: ubuntu-latest
environment: dev
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Set up JDK 8
uses: actions/setup-java@v1
with:
java-version: ${{env.JAVA_VERSION}}
- name: Login to ACR EE with the AccessKey pair
uses: aliyun/acr-login@v1
with:
login-server: "https://${{ env.ACR_EE_REGISTRY }}"
region-id: "${{ env.REGION_ID }}"
username: "QD--KeBiTeHangKong@1354706964800968"
password: "MMC@2023&ACR"
instance-id: "${{ env.ACR_EE_INSTANCE_ID }}"
- name: Build and push image to ACR EE
run: |
mvn clean package
docker build -t "$ACR_EE_REGISTRY/$ACR_EE_NAMESPACE/$ACR_EE_IMAGE:$TAG" .
docker push "$ACR_EE_REGISTRY/$ACR_EE_NAMESPACE/$ACR_EE_IMAGE:$TAG"
- name: Kustomize Set Image
run: |-
cd kustomization/overlays/dev
curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash /dev/stdin 3.8.6
./kustomize edit set image REGISTRY/NAMESPACE/IMAGE:TAG=$REGISTRY/$NAMESPACE/$IMAGE:$TAG
- name: Commit and Push
run: |
git config user.name "Chuck"
git config user.email "Chuck@users.noreply.github.com"
git remote set-url origin "$GITLAB_URL"
git commit -am "Generated Image New Tag"
git push origin develop
\ No newline at end of file
.github/workflows/master.yml 0 → 100644
name: Build and Push to ACR
on:
push:
branches: [ "master" ]
env:
REGION_ID: cn-shenzhen
REGISTRY: mmc-registry.cn-shenzhen.cr.aliyuncs.com
NAMESPACE: sharefly
IMAGE: payment
TAG: ${{ github.sha }}
ACR_EE_REGISTRY: mmc-registry.cn-shenzhen.cr.aliyuncs.com
ACR_EE_INSTANCE_ID: cri-yhk5zgfc2v1sia6l
ACR_EE_NAMESPACE: sharefly
ACR_EE_IMAGE: payment
ACR_EE_TAG: ${{ github.sha }}
JAVA_VERSION: '8'
GITLAB_URL: https://oauth2:MjVJKxB7m4tCy7symBzn@git.mmcuav.cn/iuav/payment.git
permissions:
contents: read
jobs:
build:
runs-on: ubuntu-latest
environment: prod
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Set up JDK 8
uses: actions/setup-java@v1
with:
java-version: ${{env.JAVA_VERSION}}
- name: Login to ACR EE with the AccessKey pair
uses: aliyun/acr-login@v1
with:
login-server: "https://${{ env.ACR_EE_REGISTRY }}"
region-id: "${{ env.REGION_ID }}"
username: "QD--KeBiTeHangKong@1354706964800968"
password: "MMC@2023&ACR"
instance-id: "${{ env.ACR_EE_INSTANCE_ID }}"
- name: Build and push image to ACR EE
run: |
mvn clean package
docker build -t "$ACR_EE_REGISTRY/$ACR_EE_NAMESPACE/$ACR_EE_IMAGE:$TAG" .
docker push "$ACR_EE_REGISTRY/$ACR_EE_NAMESPACE/$ACR_EE_IMAGE:$TAG"
- name: Kustomize Set Image
run: |-
cd kustomization/overlays/prod
curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash /dev/stdin 3.8.6
./kustomize edit set image REGISTRY/NAMESPACE/IMAGE:TAG=$REGISTRY/$NAMESPACE/$IMAGE:$TAG
- name: Commit and Push
run: |
git config user.name "Chuck"
git config user.email "Chuck@users.noreply.github.com"
git remote set-url origin "$GITLAB_URL"
git commit -am "Generated Image New Tag"
git push origin master
\ No newline at end of file
Dockerfile 0 → 100644
FROM openjdk:8-jdk-alpine
ARG JAVA_OPTS
ENV JAVA_OPTS=$JAVA_OPTS
RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
COPY target/payment-0.0.1-SNAPSHOT.jar payment.jar
EXPOSE 8088
# For Spring-Boot project, use the entrypoint below to reduce Tomcat startup time.
ENTRYPOINT exec java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar payment.jar
kustomization/base/configMap.yaml 0 → 100644
apiVersion: v1
kind: ConfigMap
metadata:
name: payment-map
namespace: default
data:
SPRING_PROFILES_ACTIVE: default
kustomization/base/deployment.yaml 0 → 100644
apiVersion: apps/v1
kind: Deployment
metadata:
name: payment-deployment
namespace: default
spec:
replicas: 1
selector:
matchLabels:
app: payment
template:
metadata:
labels:
app: payment
spec:
containers:
- name: payment
image: REGISTRY/NAMESPACE/IMAGE:TAG
resources:
limits:
memory: 1024Mi
cpu: 100m
ports:
- containerPort: 8088
env:
- name: SPRING_PROFILES_ACTIVE
valueFrom:
configMapKeyRef:
name: payment-map
key: SPRING_PROFILES_ACTIVE
\ No newline at end of file
kustomization/base/kustomization.yaml 0 → 100644
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
commonLabels:
app: payment
resources:
- ./deployment.yaml
- ./service.yaml
- ./configMap.yaml
\ No newline at end of file
kustomization/base/service.yaml 0 → 100644
apiVersion: v1
kind: Service
metadata:
name: payment-svc
namespace: default
spec:
selector:
app: payment
ports:
- protocol: TCP
port: 8088
\ No newline at end of file
kustomization/overlays/dev/configMap.yaml 0 → 100644
apiVersion: v1
kind: ConfigMap
metadata:
name: payment-map
data:
SPRING_PROFILES_ACTIVE: dev
\ No newline at end of file
kustomization/overlays/dev/kustomization.yaml 0 → 100644
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- ../../base
#namePrefix: dev-
namespace: dev
commonLabels:
variant: dev
commonAnnotations:
note: This is dev!
patches:
- path: ./configMap.yaml
\ No newline at end of file
kustomization/overlays/prod/configMap.yaml 0 → 100644
apiVersion: v1
kind: ConfigMap
metadata:
name: payment-map
data:
SPRING_PROFILES_ACTIVE: prod
\ No newline at end of file
kustomization/overlays/prod/increase_replicas.yaml 0 → 100644
apiVersion: apps/v1
kind: Deployment
metadata:
name: payment-deployment
spec:
replicas: 1
\ No newline at end of file
kustomization/overlays/prod/kustomization.yaml 0 → 100644
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- ../../base
namespace: prod
#namePrefix: prod-
commonLabels:
variant: prod
commonAnnotations:
note: This is prod!
patches:
- path: increase_replicas.yaml
- path: configMap.yaml
\ No newline at end of file
pom.xml
......@@ -14,19 +14,69 @@
<name>payment</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>17</java.version>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.3</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<!--<scope>runtime</scope>-->
</dependency>
<!--swagger-->
<dependency>
<groupId>com.github.xiaoymin</groupId>
<artifactId>knife4j-spring-boot-starter</artifactId>
<version>3.0.2</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>2.0.32</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.3.4</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
<version>3.0.0</version>
<!--<scope>compile</scope>-->
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>
<build>
......
src/main/java/com/mmc/payment/common/AmtUtil.java 0 → 100644
package com.mmc.payment.common;
import java.math.BigDecimal;
/**
* @Author small
* @Date 2023/5/24 10:15
* @Version 1.0
*/
public class AmtUtil {
private static final BigDecimal minCashCost = BigDecimal.valueOf(-99999999.99);// -9999万9999元.99
private static final BigDecimal maxCashCost = BigDecimal.valueOf(99999999.99);// 9999万9999元.99
private static final BigDecimal minRepeatCost = BigDecimal.ZERO;// 0
private static final BigDecimal maxRepeatCost = BigDecimal.valueOf(99999999.99);// 9999万9999元.99
public static final BigDecimal REBATE_RATE = (BigDecimal.valueOf(0.01).setScale(2, BigDecimal.ROUND_DOWN));// 返利的百分比
/**
* 变更-金额范围
*
* @param amtPaid
* @return
*/
public static boolean vertifyAmt(BigDecimal amtPaid) {
return (amtPaid != null && (amtPaid.compareTo(minCashCost) >= 0) && (amtPaid.compareTo(maxCashCost) <= 0));
}
/**
* 还款-金额范围
*
* @param amtPaid
* @return
*/
public static boolean vertifyRepeatAmt(BigDecimal amtPaid) {
return (amtPaid != null && (amtPaid.compareTo(minRepeatCost) > 0) && (amtPaid.compareTo(maxRepeatCost) <= 0));
}
public static boolean vertifyRepoAmt(BigDecimal amtPaid) {
return (amtPaid != null && (amtPaid.compareTo(BigDecimal.ZERO) > 0) && (amtPaid.compareTo(maxCashCost) <= 0));
}
}
src/main/java/com/mmc/payment/common/BaseController.java 0 → 100644
package com.mmc.payment.common;
import com.alibaba.fastjson.JSONObject;
import com.mmc.payment.config.AuthHandler;
import com.mmc.payment.exception.BizException;
import com.mmc.payment.jwt.JwtConstant;
import com.mmc.payment.model.dto.BaseAccountDTO;
import com.mmc.payment.model.dto.CurrentUserDTO;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import javax.servlet.http.HttpServletRequest;
/**
* @Author small
* @Date 2023/5/24 9:54
* @Version 1.0
*/
public abstract class BaseController {
@Autowired
private AuthHandler 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(HttpServletRequest request) {
String token = request.getHeader("token");
String json = stringRedisTemplate.opsForValue().get(token);
if (StringUtils.isBlank(json)){
throw new BizException(ResultEnum.LOGIN_ACCOUNT_STATUS_ERROR);
}
BaseAccountDTO baseAccountDTO= JSONObject.parseObject(json, BaseAccountDTO.class);
return baseAccountDTO;
}
}
src/main/java/com/mmc/payment/common/BaseErrorInfoInterface.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/23 18:42
* @Version 1.0
*/
public interface BaseErrorInfoInterface {
/**
* 错误码
*
* @return
*/
String getResultCode();
/**
* 错误描述
*
* @return
*/
String getResultMsg();
}
src/main/java/com/mmc/payment/common/CodeUtil.java 0 → 100644
package com.mmc.payment.common;
import java.util.Random;
/**
* @Author small
* @Date 2023/5/23 19:33
* @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/payment/common/Create.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/24 10:05
* @Version 1.0
*/
public interface Create {
}
src/main/java/com/mmc/payment/common/Freeze.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/23 19:18
* @Version 1.0
*/
public interface Freeze {
}
src/main/java/com/mmc/payment/common/JsonUtil.java 0 → 100644
package com.mmc.payment.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/23 19:31
* @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/payment/common/Page.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/23 19:14
* @Version 1.0
*/
public interface Page {
}
src/main/java/com/mmc/payment/common/PageResult.java 0 → 100644
package com.mmc.payment.common;
import com.mmc.payment.model.qo.BaseInfoQO;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/23 19:17
* @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/payment/common/RedisConstant.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/23 19:30
* @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/payment/common/Refund.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/24 10:05
* @Version 1.0
*/
public interface Refund {
}
src/main/java/com/mmc/payment/common/ResultBody.java 0 → 100644
package com.mmc.payment.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/23 19:19
* @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/payment/common/ResultEnum.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/23 18:43
* @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", "先点击确认添加分成对象"),
THE_REQUEST_IS_NOT_AUTHENTICATED("2013","请求未经过鉴权"),
THE_TOKEN_IS_INVALID("2014","token失效") ;;
/**
* 错误码
*
* @return
*/
public 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/payment/common/Share.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/24 10:05
* @Version 1.0
*/
public interface Share {
}
src/main/java/com/mmc/payment/common/TDateUtil.java 0 → 100644
package com.mmc.payment.common;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* @Author small
* @Date 2023/5/23 19:33
* @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/payment/common/Tenant.java 0 → 100644
package com.mmc.payment.common;
import lombok.Data;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/29 10:38
* @Version 1.0
*/
@Data
public class Tenant implements Serializable {
/**
* 用户id
*/
private Integer userId;
/**
* 所在机构id
*/
private Integer tenantId;
/**
* 用户名称
*/
private String userName;
/**
* 管理机构id集合
*/
private String tenantIds;
/**
* 菜单路由路径集合
*/
private String token;
/**
* 角色id
*/
private Integer roleId;
/**
* 角色类型，1超管 2其他角色
*/
private Integer roleType;
public Tenant(String userName) {
this.userId = userId;
this.tenantId = tenantId;
this.userName = userName;
this.tenantIds = tenantIds;
this.token = token;
this.roleId = roleId;
this.roleType = roleType;
}
/**
* userid相同，认为是同个用户
*
* @param o
* @return
*/
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o instanceof Tenant) {
Tenant tenant = (Tenant) o;
return getUserId().equals(tenant.getUserId());
} else {
return false;
}
}
@Override
public int hashCode() {
int result = 17;
result = 31 * result + getUserId().hashCode();
return result;
}
}
src/main/java/com/mmc/payment/common/Update.java 0 → 100644
package com.mmc.payment.common;
/**
* @Author small
* @Date 2023/5/23 19:40
* @Version 1.0
*/
public interface Update {
}
src/main/java/com/mmc/payment/config/Audience.java 0 → 100644
package com.mmc.payment.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* @Author small
* @Date 2023/5/29 10:39
* @Version 1.0
*/
@Data
@ConfigurationProperties(prefix = "audience")
@Component
public class Audience {
private String clientId;
private String base64Secret;
private String name;
private long expiresSecond;
}
src/main/java/com/mmc/payment/config/AuthHandler.java 0 → 100644
package com.mmc.payment.config;
import com.alibaba.fastjson.JSONArray;
import com.mmc.payment.common.JsonUtil;
import com.mmc.payment.common.RedisConstant;
import com.mmc.payment.common.ResultEnum;
import com.mmc.payment.exception.BizException;
import com.mmc.payment.jwt.JwtConstant;
import com.mmc.payment.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/23 19:22 @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/payment/config/JwtUtil.java 0 → 100644
package com.mmc.payment.config;
import com.mmc.payment.common.CodeUtil;
import com.mmc.payment.jwt.JwtConstant;
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/23 19:32
* @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/payment/config/RepeatSubmit.java 0 → 100644
package com.mmc.payment.config;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @Author small
* @Date 2023/5/24 10:03
* @Version 1.0
*/
@Target(ElementType.METHOD) // 作用于方法上
@Retention(RetentionPolicy.RUNTIME) // 运行时
public @interface RepeatSubmit {
/**
* 设置请求锁定时间 默认5秒
*/
long lockTime() default 5000L;
/**
* 当发生重复提交时候默认返回的错误信息
*/
String errMsg() default "重复提交,请 second 秒后重试";
/**
* 是否允许lockTime时间内可以再次提交
*/
boolean allowAgain() default true;
}
src/main/java/com/mmc/payment/config/RepoCashMethod.java 0 → 100644
package com.mmc.payment.config;
/**
* @Author small
* @Date 2023/5/24 10:14
* @Version 1.0
*/
public enum RepoCashMethod {
REG(100, "充值"), RENT(200, "邮寄"), CNO(300, "租赁结算"), REFUND(400, "退款"), DRAWAL(500, "提现"), HANDLER(600, "手动扣除");
RepoCashMethod(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/payment/config/RestTemplateConfig.java 0 → 100644
package com.mmc.payment.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
/**
* @Author small
* @Date 2023/5/25 17:45
* @Version 1.0
*/
@Configuration
public class RestTemplateConfig {
@Bean
public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
return new RestTemplate(factory);
}
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
// 设置连接超时
factory.setConnectTimeout(15000);
factory.setReadTimeout(5000);
return factory;
}
}
src/main/java/com/mmc/payment/config/SwaggerConfig.java 0 → 100644
package com.mmc.payment.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.web.servlet.handler.SimpleUrlHandlerMapping;
import org.springframework.web.servlet.resource.PathResourceResolver;
import org.springframework.web.servlet.resource.ResourceHttpRequestHandler;
import org.springframework.web.util.UrlPathHelper;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;
import javax.servlet.ServletContext;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* @Author small
* @Date 2023/5/23 17:44
* @Version 1.0
*/
@Configuration
@EnableSwagger2WebMvc
public class SwaggerConfig {
@Bean(value = "defaultApi2")
public Docket defaultApi2() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(
new ApiInfoBuilder()
.title("产品管理系统API")
.description("产品管理系统API")
.termsOfServiceUrl("")
.version("0.0.1")
.build())
// 分组名称
.groupName("开发版本")
.select()
// 这里指定Controller扫描包路径0
.apis(RequestHandlerSelectors.basePackage("com.mmc.payment"))
.paths(PathSelectors.any())
.build();
}
public static final String DEFAULT_PATH = "swagger";
/**
* SwaggerUI资源访问，自定义访问路径前缀
*
* @param servletContext
* @param order
* @return
* @throws Exception
*/
@Bean
public SimpleUrlHandlerMapping swaggerUrlHandlerMapping(
ServletContext servletContext, @Value("${swagger.mapping.order:10}") int order)
throws Exception {
SimpleUrlHandlerMapping urlHandlerMapping = new SimpleUrlHandlerMapping();
Map<String, ResourceHttpRequestHandler> urlMap = new HashMap<>();
{
PathResourceResolver pathResourceResolver = new PathResourceResolver();
pathResourceResolver.setAllowedLocations(
new ClassPathResource("META-INF/resources/webjars/"));
pathResourceResolver.setUrlPathHelper(new UrlPathHelper());
ResourceHttpRequestHandler resourceHttpRequestHandler = new ResourceHttpRequestHandler();
resourceHttpRequestHandler.setLocations(
Arrays.asList(new ClassPathResource("META-INF/resources/webjars/")));
resourceHttpRequestHandler.setResourceResolvers(Arrays.asList(pathResourceResolver));
resourceHttpRequestHandler.setServletContext(servletContext);
resourceHttpRequestHandler.afterPropertiesSet();
// 设置新的路径
urlMap.put(DEFAULT_PATH + "/webjars/**", resourceHttpRequestHandler);
}
{
PathResourceResolver pathResourceResolver = new PathResourceResolver();
pathResourceResolver.setAllowedLocations(new ClassPathResource("META-INF/resources/"));
pathResourceResolver.setUrlPathHelper(new UrlPathHelper());
ResourceHttpRequestHandler resourceHttpRequestHandler = new ResourceHttpRequestHandler();
resourceHttpRequestHandler.setLocations(
Arrays.asList(new ClassPathResource("META-INF/resources/")));
resourceHttpRequestHandler.setResourceResolvers(Arrays.asList(pathResourceResolver));
resourceHttpRequestHandler.setServletContext(servletContext);
resourceHttpRequestHandler.afterPropertiesSet();
// 设置新的路径
urlMap.put(DEFAULT_PATH + "/**", resourceHttpRequestHandler);
}
urlHandlerMapping.setUrlMap(urlMap);
// 调整DispatcherServlet关于SimpleUrlHandlerMapping的排序
urlHandlerMapping.setOrder(order);
return urlHandlerMapping;
}
}
src/main/java/com/mmc/payment/config/TenantContext.java 0 → 100644
package com.mmc.payment.config;
import com.mmc.payment.common.Tenant;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
/**
* @Author small
* @Date 2023/5/29 10:38
* @Version 1.0
*/
@Slf4j
public class TenantContext {
private static ThreadLocal<Tenant> tenantHolder = new ThreadLocal<>();
public static void setTenant(Tenant tenant) {
tenantHolder.set(tenant);
}
public static Tenant getTenant() {
return tenantHolder.get();
}
public static Integer getUserId() {
return getTenant().getUserId();
}
public static Integer getTenantId() {
return getTenant().getTenantId();
}
public static Integer getRoleId() {
return getTenant().getRoleId();
}
public static boolean exists() {
return getTenant() != null;
}
public static void clear() {
tenantHolder.remove();
}
public static Tenant buildTenant( String accountNo ) {
if (StringUtils.isBlank(accountNo)) {
log.error("登录信息[accountNo]获取异常");
return null;
}
return new Tenant(accountNo);
}
/**
* valid tenantId is correct
*/
private static boolean validNumeric(String number) {
return StringUtils.isNotEmpty(number) && StringUtils.isNumeric(number);
}
}
src/main/java/com/mmc/payment/config/UserPorts.java 0 → 100644
package com.mmc.payment.config;
import java.util.HashSet;
import java.util.Set;
/**
* @Author small
* @Date 2023/5/23 19:15
* @Version 1.0
*/
public class UserPorts {
public static final String USER_PORT = "USER_PORT";
public static final String FLYER_PORT = "FLYER_PORT";
public static final String REPO_PORT = "REPO_PORT";
public static final String MALL_PORT = "MALL_PORT";
public static final Set<String> ports = new HashSet<String>();
static {
ports.add(REPO_PORT);
ports.add(USER_PORT);
ports.add(FLYER_PORT);
ports.add(MALL_PORT);
}
}
src/main/java/com/mmc/payment/controller/RepoAccountController.java 0 → 100644
package com.mmc.payment.controller;
import com.mmc.payment.common.ResultBody;
import com.mmc.payment.config.AuthHandler;
import com.mmc.payment.jwt.JwtConstant;
import com.mmc.payment.model.dto.BaseAccountDTO;
import com.mmc.payment.model.dto.RepoAccountDTO;
import com.mmc.payment.model.qo.RepoAccountQO;
import com.mmc.payment.service.RepoAccountService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
/**
* @Author small
* @Date 2023/5/23 18:40
* @Version 1.0
*/
@Api(tags = {"云仓-账号相关-接口"})
@RestController
@RequestMapping("/repoaccount/")
public class RepoAccountController {
@Autowired
private RepoAccountService repoAccountService;
@Autowired
private AuthHandler authHandler;
@ApiOperation(value = "PC端-云仓-消耗管理")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = RepoAccountDTO.class)})
@PostMapping("listPagePayManager")
public ResultBody listPagePayManager(HttpServletRequest request, @RequestBody RepoAccountQO param) {
return ResultBody.success(repoAccountService.listPagePayManager(param,this.getCurrentAccount(request)));
}
/**
* 获取当前登录账号信息
*/
public BaseAccountDTO getCurrentAccount(HttpServletRequest request) {
String token = request.getHeader(JwtConstant.TOKENKEY);
return authHandler.getCurrentAccount(token);
}
}
src/main/java/com/mmc/payment/controller/RepoCashController.java 0 → 100644
package com.mmc.payment.controller;
import com.mmc.payment.common.BaseController;
import com.mmc.payment.common.ResultBody;
import com.mmc.payment.config.RepeatSubmit;
import com.mmc.payment.model.dto.PayCashResultDTO;
import com.mmc.payment.model.dto.RepoCashDTO;
import com.mmc.payment.model.qo.RepoCashQO;
import com.mmc.payment.model.vo.RepoCashVO;
import com.mmc.payment.model.vo.RepoOrderPayVO;
import com.mmc.payment.service.RepoCashService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiResponse;
import io.swagger.annotations.ApiResponses;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
/**
* @Author small @Date 2023/5/24 9:53 @Version 1.0
*/
@Api(tags = {"现金管理"})
@RestController
@RequestMapping("/repocash/")
public class RepoCashController extends BaseController {
@Autowired private RepoCashService repoCashService;
@Autowired private StringRedisTemplate stringRedisTemplate;
@ApiOperation(value = "web-订单支付")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = PayCashResultDTO.class)})
@PostMapping("orderPayment")
public PayCashResultDTO orderPayment(HttpServletRequest request, @RequestParam String orderNo) {
return repoCashService.orderPayment(this.getCurrentAccount(request), orderNo);
}
@ApiOperation(value = "支付订单-充值扣款")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = PayCashResultDTO.class)})
@ApiIgnore
@PostMapping("PayCashOrder")
public PayCashResultDTO feignPayCashOrder(@RequestBody RepoOrderPayVO orderPay) {
return repoCashService.payCashOrder(orderPay);
}
@ApiOperation(value = "当前用户剩余的余额")
@GetMapping("RemainingBalance")
public BigDecimal RemainingBalance(
@RequestParam(value = "repoAccountId", required = true) Integer repoAccountId) {
String s = stringRedisTemplate.opsForValue().get("R2023052814538712");
return repoCashService.RemainingBalance(repoAccountId);
}
@ApiOperation(value = "余额变更-分页-列表")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = RepoCashDTO.class)})
@PostMapping("listPageCash")
public ResultBody listPageCash(@RequestBody RepoCashQO param) {
return ResultBody.success(repoCashService.listPageRepoCash(param));
}
@ApiOperation(value = "余额变更-修改备注")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = ResultBody.class)})
@GetMapping("updateCashRemark")
public ResultBody updateCashRemark(@RequestParam Integer id, @RequestParam() String remark) {
repoCashService.updateCashRemark(id, remark);
return ResultBody.success();
}
@ApiOperation(value = "v1.0.1Yes-现金-充值")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = ResultBody.class)})
@RepeatSubmit
@PostMapping("reqCash")
public ResultBody reqCash(HttpServletRequest request, @RequestBody RepoCashVO param) {
return repoCashService.reqCash(this.getCurrentAccount(request), param);
}
@ApiOperation(value = "v1.0.1-Yes现金-手动扣除")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = ResultBody.class)})
@RepeatSubmit
@PostMapping("dedCash")
public ResultBody dedCash(HttpServletRequest request, @RequestBody RepoCashVO param) {
return repoCashService.dedCash(this.getCurrentAccount(request), param);
}
@ApiIgnore
@ApiOperation(value = "查询退款金额")
@ApiResponses({@ApiResponse(code = 200, message = "OK", response = RepoCashDTO.class)})
@GetMapping("feignRefundInfo")
public RepoCashDTO feignRefundInfo(@RequestParam String refundNo) {
return repoCashService.getRefundInfo(refundNo);
}
}
src/main/java/com/mmc/payment/controller/SwaggerResourceController.java 0 → 100644
package com.mmc.payment.controller;
import com.mmc.payment.config.SwaggerConfig;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.http.ResponseEntity;
import org.springframework.plugin.core.PluginRegistry;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import springfox.documentation.annotations.ApiIgnore;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.DocumentationCache;
import springfox.documentation.spring.web.json.Json;
import springfox.documentation.spring.web.json.JsonSerializer;
import springfox.documentation.swagger.web.ApiResourceController;
import springfox.documentation.swagger.web.SecurityConfiguration;
import springfox.documentation.swagger.web.SwaggerResource;
import springfox.documentation.swagger.web.UiConfiguration;
import springfox.documentation.swagger2.mappers.ServiceModelToSwagger2Mapper;
import springfox.documentation.swagger2.web.Swagger2ControllerWebMvc;
import springfox.documentation.swagger2.web.WebMvcSwaggerTransformationFilter;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
/**
* @Author small
* @Date 2023/5/23 17:44
* @Version 1.0
*/
@Controller
@ApiIgnore
@RequestMapping(SwaggerConfig.DEFAULT_PATH)
public class SwaggerResourceController implements InitializingBean {
private final ApiResourceController apiResourceController;
private final DocumentationCache documentationCache;
private final ServiceModelToSwagger2Mapper mapper;
private final JsonSerializer jsonSerializer;
private final PluginRegistry<WebMvcSwaggerTransformationFilter, DocumentationType>
transformations;
private static final String HAL_MEDIA_TYPE = "application/hal+json";
private Swagger2ControllerWebMvc swagger2ControllerWebMvc;
public SwaggerResourceController(
ApiResourceController apiResourceController,
DocumentationCache documentationCache,
ServiceModelToSwagger2Mapper mapper,
JsonSerializer jsonSerializer,
PluginRegistry<WebMvcSwaggerTransformationFilter, DocumentationType> transformations) {
this.apiResourceController = apiResourceController;
this.documentationCache = documentationCache;
this.mapper = mapper;
this.jsonSerializer = jsonSerializer;
this.transformations = transformations;
}
@Override
public void afterPropertiesSet() throws Exception {
swagger2ControllerWebMvc =
new Swagger2ControllerWebMvc(documentationCache, mapper, jsonSerializer, transformations);
}
/**
* Swagger API首页地址
*
* @return 首页地址
*/
@RequestMapping
public ModelAndView index() {
return new ModelAndView("redirect:" + SwaggerConfig.DEFAULT_PATH + "/doc.html");
}
@RequestMapping("/swagger-resources/configuration/security")
@ResponseBody
public ResponseEntity<SecurityConfiguration> securityConfiguration() {
return apiResourceController.securityConfiguration();
}
@RequestMapping("/swagger-resources/configuration/ui")
@ResponseBody
public ResponseEntity<UiConfiguration> uiConfiguration() {
return apiResourceController.uiConfiguration();
}
@RequestMapping("/swagger-resources")
@ResponseBody
public ResponseEntity<List<SwaggerResource>> swaggerResources() {
return apiResourceController.swaggerResources();
}
@RequestMapping(
value = "/v2/api-docs",
method = RequestMethod.GET,
produces = {APPLICATION_JSON_VALUE, HAL_MEDIA_TYPE})
@ResponseBody
public ResponseEntity<Json> getDocumentation(
@RequestParam(value = "group", required = false) String swaggerGroup,
HttpServletRequest servletRequest) {
return swagger2ControllerWebMvc.getDocumentation(swaggerGroup, servletRequest);
}
}
src/main/java/com/mmc/payment/dao/RepoAccountDao.java 0 → 100644
package com.mmc.payment.dao;
import com.mmc.payment.entity.RepoAccountDO;
import com.mmc.payment.entity.RepoWalletDO;
import com.mmc.payment.model.qo.RepoAccountQO;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* @Author small
* @Date 2023/5/23 19:37
* @Version 1.0
*/
@Mapper
public interface RepoAccountDao {
List<RepoAccountDO> listPagePayManager(RepoAccountQO param);
int countPagePayManager(RepoAccountQO param);
List<RepoWalletDO> listWalletInfo(RepoAccountQO param);
}
src/main/java/com/mmc/payment/dao/RepoCashDao.java 0 → 100644
package com.mmc.payment.dao;
import com.mmc.payment.entity.RepoCashDO;
import com.mmc.payment.entity.RepoWalletDO;
import com.mmc.payment.model.qo.RepoCashQO;
import org.apache.ibatis.annotations.Mapper;
import java.math.BigDecimal;
import java.util.List;
/**
* @Author small @Date 2023/5/24 10:10 @Version 1.0
*/
@Mapper
public interface RepoCashDao {
RepoCashDO getRefundCashInfo(String refundNo);
void insertRepoCash(RepoCashDO rc);
void updateCashRemark(Integer id, String remark);
List<RepoCashDO> listPagePFRepoCash(RepoCashQO param);
int countPagePFRepoCash(RepoCashQO param);
RepoWalletDO getRepoWalletInfo(Integer repoAccountId);
void updateRepoWalletAmt(Integer repoAccountId, BigDecimal chageAmt);
BigDecimal RemainingBalance(Integer repoAccountId);
void updateWalletAmt(Integer repoAccountId, BigDecimal addAmt, BigDecimal addPaid);
void orderPayment(RepoCashDO repoCashDO);
}
src/main/java/com/mmc/payment/entity/OrderInfoDO.java 0 → 100644
package com.mmc.payment.entity;
import com.mmc.payment.model.dto.KdnExpDTO;
import com.mmc.payment.model.dto.OrderReceiptDTO;
import com.mmc.payment.model.dto.OrderRefundDTO;
import com.mmc.payment.model.dto.OrderVcuDTO;
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/29 13:55 @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
// @ApiModel(value = "com.mmc.csf.model.dto.OrderInfoDTO", description = "云仓订单DTO")
public class OrderInfoDO implements Serializable {
private static final long serialVersionUID = 1572467108563651846L;
@ApiModelProperty(value = "ID")
private Integer id;
@ApiModelProperty(value = "订单编号")
private String orderNo;
@ApiModelProperty(value = "商品ID")
private Integer wareInfoId;
@ApiModelProperty(value = "商品编号")
private String wareNo;
@ApiModelProperty(value = "商品标题")
private String wareTitle;
@ApiModelProperty(value = "商品图片")
private String wareImg;
@ApiModelProperty(value = "套餐（sku）ID")
private Integer skuInfoId;
@ApiModelProperty(value = "套餐（sku）名称")
private String skuTitle;
@ApiModelProperty(value = "购买用户ID")
private Integer repoAccountId;
@ApiModelProperty(value = "用户UID")
private String uid;
@ApiModelProperty(value = "买家name")
private String buyerName;
@ApiModelProperty(value = "买家电话")
private String buyerPhone;
@ApiModelProperty(value = "单价")
private BigDecimal unitPrice;
@ApiModelProperty(value = "购买的商品数量")
private Integer wareNum;
@ApiModelProperty(value = "应付款金额")
private BigDecimal shouldPay;
@ApiModelProperty(value = "实收款金额")
private BigDecimal actualPay;
@ApiModelProperty(value = "订单类型：0租赁 100购买")
private Integer orderType;
@ApiModelProperty(value = "押金")
private BigDecimal deposit;
@ApiModelProperty(value = "租金总金额")
private BigDecimal rentPrice;
@ApiModelProperty(value = "租约开始日")
private Date startDate;
@ApiModelProperty(value = "租约结束日")
private Date endDate;
@ApiModelProperty(value = "付款天数")
private Integer payDay;
@ApiModelProperty(value = "交易状态：查订单状态字典")
private String tranStatus;
@ApiModelProperty(value = "减库方式 0:买家拍下减库存 1:卖家付款减库存")
private Integer exWare;
@ApiModelProperty(value = "用户备注")
private String remark;
@ApiModelProperty(value = "平台人员备注")
private String pfRemark;
@ApiModelProperty(value = "关闭原因")
private String shutReason;
@ApiModelProperty(value = "交易编号")
private String payNo;
@ApiModelProperty(value = "支付时间")
private Date payTime;
@ApiModelProperty(value = "发货时间")
private Date sendWareTime;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "物流信息/收货地址信息")
private OrderReceiptDTO receipt;
@ApiModelProperty(value = "退款单详情信息,无则为null")
private OrderRefundDTO orderRefund;
@ApiModelProperty(value = "发货-物流动态,无则为null")
private KdnExpDTO express;
@ApiModelProperty(value = "退货-物流动态,无则为null")
private KdnExpDTO refundExpress;
@ApiModelProperty(value = "质检详情,无则为null")
private List<OrderVcuDTO> vcus;
@ApiModelProperty(value = "归还时间")
private Date returnTime;
@ApiModelProperty(value = "优惠券id", example = "221")
private Integer couponId;
@ApiModelProperty(value = "规格id", example = "1")
private Integer specsId;
@ApiModelProperty(value = "余额", example = "4")
private BigDecimal balance;
}
src/main/java/com/mmc/payment/entity/RepoAccountDO.java 0 → 100644
package com.mmc.payment.entity;
import com.mmc.payment.model.dto.RepoAccountDTO;
import com.mmc.payment.model.dto.RepoRcdTeamDTO;
import com.mmc.payment.model.dto.RepoRebateWalletDTO;
import com.mmc.payment.model.vo.RepoAccountVO;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
/**
* @Author small
* @Date 2023/5/23 19:39
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RepoAccountDO implements Serializable {
private static final long serialVersionUID = 6313612168648022544L;
private Integer id;
private String uid;
private String accountName;
private Integer accountType;
private String phoneNum;
private Integer realAuthStatus;
private Integer entAuthStatus;
private Integer channelAuthStatus;
private Integer channelClass;
private String openId;
private String unionId;
private String nickName;
private String resAddress;
private String headerImg;
private BigDecimal lon;
private BigDecimal lat;
private String ports;
private String remark;
private Integer deleted;
private Date createTime;
private Date updateTime;
private Integer sale;
private Integer source;
private Integer rcdCompanyId;
private RepoAccountDO rcdRepo;
/**
* 额外字段
*
*/
private Integer white;
private Date entAuthTime;
private String entName;
private Date rcdCreateTime;
private String rcdRemark;
public RepoAccountDTO buildRepoAccountDTO() {
Integer white = 0;
if(rcdRepo !=null && rcdRepo.getSale() ==1){
white = 1;
}
return RepoAccountDTO.builder().id(this.id).uid(this.uid).accountName(this.accountName)
.accountType(this.accountType).phoneNum(this.phoneNum).realAuthStatus(this.realAuthStatus)
.entAuthStatus(this.entAuthStatus).channelAuthStatus(this.channelAuthStatus).nickName(this.nickName)
.resAddress(this.resAddress).headerImg(this.headerImg).lon(this.lon).lat(this.lat).remark(this.remark)
.deleted(this.deleted).createTime(this.createTime).updateTime(this.updateTime)
.ports(StringUtils.isEmpty(this.ports) ? null
: new HashSet<String>(Arrays.asList(this.ports.split(","))))
.entAuthTime(this.entAuthTime).unionId(this.unionId).entName(this.entName).openId(this.openId)
.rcdUid(this.rcdRepo == null ? null : this.rcdRepo.getUid())
.rcdAccountId(this.rcdRepo == null ? null : this.rcdRepo.getId())
.rcdAccountName(this.rcdRepo == null ? null : this.rcdRepo.getAccountName())
.rcdNickName(this.rcdRepo == null ? null : this.rcdRepo.getNickName())
.channelClass(this.channelClass).sale(this.sale).white(white).source(this.source)
.rcdCompanyId(this.rcdCompanyId)
.build();
}
public RepoRcdTeamDTO builderRepoRcdTeamDTO(){
return RepoRcdTeamDTO.builder().RepoAccountName(this.accountName).id(this.id).accountType(this.accountType)
.realAuthStatus(this.realAuthStatus).entAuthStatus(this.entAuthStatus).createTime(this.rcdCreateTime)
.phoneNum(this.phoneNum).nickName(this.nickName).remark(this.rcdRemark).uid(this.uid).entName(this.entName).build();
}
public RepoRebateWalletDTO buildRepoRebateWalletDTO(){
return RepoRebateWalletDTO.builder().repoAccountId(this.id).uid(this.uid).nickName(this.getNickName()).build();
}
public void buildName() {
if (StringUtils.isBlank(this.accountName) && StringUtils.isBlank(this.entName)) {
this.accountName = null;
} else if (StringUtils.isBlank(this.accountName) && !StringUtils.isBlank(this.entName)) {
this.accountName = this.entName;
} else if (!StringUtils.isBlank(this.accountName) && !StringUtils.isBlank(this.entName)) {
StringBuffer sb = new StringBuffer();
sb.append(this.accountName);
sb.append("(");
sb.append(this.entName);
sb.append(")");
this.accountName = sb.toString();
}
}
public RepoAccountDO(RepoAccountVO repoAccountVO) {
this.id = repoAccountVO.getId();
this.headerImg = repoAccountVO.getHeaderImg();
this.nickName = repoAccountVO.getNickName();
this.resAddress = repoAccountVO.getResAddress();
this.lon = repoAccountVO.getLon();
this.lat = repoAccountVO.getLat();
}
}
src/main/java/com/mmc/payment/entity/RepoCashDO.java 0 → 100644
package com.mmc.payment.entity;
import com.mmc.payment.model.dto.RepoCashDTO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/24 10:09
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RepoCashDO implements Serializable {
private static final long serialVersionUID = -7930603317037474755L;
private Integer id;
private Integer repoAccountId;
private String uid;
private String accountName;
private Integer orderInfoId;
private String orderNo;
private Integer skuInfoId;
private String skuTitle;
private Integer wareInfoId;
private String wareNo;
private String wareTitle;
private String payNo;
private Integer payMethod;
private BigDecimal amtPaid;
private BigDecimal cashAmt;
private Date payTime;
private String refundNo;
private String voucher;
private String remark;
private Integer createUser;
private Date createTime;
private Integer updateUser;
private Date updateTime;
public RepoCashDTO buildRepoCashDTO() {
return RepoCashDTO.builder().id(this.id).repoAccountId(this.repoAccountId).uid(this.uid)
.accountName(this.accountName).orderInfoId(this.orderInfoId).orderNo(this.orderNo)
.skuInfoId(this.skuInfoId).skuTitle(this.skuTitle).wareInfoId(this.wareInfoId).wareNo(this.wareNo)
.wareTitle(this.wareTitle).payNo(this.payNo).payMethod(this.payMethod).amtPaid(this.amtPaid)
.refundNo(this.refundNo).createUser(this.createUser)
.voucher(StringUtils.isBlank(this.voucher) ? null : Arrays.asList(this.voucher.split(",")))
.cashAmt(this.cashAmt).payTime(this.payTime).remark(this.remark).build();
}
}
src/main/java/com/mmc/payment/entity/RepoWalletDO.java 0 → 100644
package com.mmc.payment.entity;
import com.mmc.payment.model.dto.RepoWalletDTO;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* @Author small
* @Date 2023/5/23 20:30
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class RepoWalletDO implements Serializable {
private static final long serialVersionUID = 6230679407746486112L;
private Integer id;
private Integer repoAccountId;
private BigDecimal cashAmt;
private BigDecimal cashPaid;
private BigDecimal cashFreeze;
private BigDecimal rcdRebateAmt;
private BigDecimal rebateWdl;
private BigDecimal rebateFreeze;
private String remark;
private Date updateTime;
private Date createTime;
public void initWallet(Integer repoAccountId) {
this.repoAccountId = repoAccountId;
this.cashAmt = BigDecimal.ZERO;
this.cashPaid = BigDecimal.ZERO;
this.cashFreeze = BigDecimal.ZERO;
this.createTime = new Date();
}
public RepoWalletDTO buildRepoWalletDTO() {
return RepoWalletDTO.builder().id(this.id).repoAccountId(this.repoAccountId).cashAmt(this.cashAmt)
.cashPaid(this.cashPaid).cashFreeze(this.cashFreeze).rcdRebateAmt(this.rcdRebateAmt).rebateWdl(this.rebateWdl)
.rebateFreeze(this.rebateFreeze).remark(this.remark).build();
}
/* public RepoRebateSubDTO buildRepoRebateSubDTO(){
RepoRebateSubDTO repoRebateSubDTO = RepoRebateSubDTO.builder().repoAccountId(this.repoAccountId).rcdRebateAmt(this.rcdRebateAmt)
.rebateFreeze(this.rebateFreeze).rebateWdl(this.rebateWdl).build();
repoRebateSubDTO.computerTotalRebate();
return repoRebateSubDTO;
}*/
}
src/main/java/com/mmc/payment/exception/BizException.java 0 → 100644
package com.mmc.payment.exception;
import com.mmc.payment.common.BaseErrorInfoInterface;
import com.mmc.payment.common.ResultEnum;
import static com.mmc.payment.common.ResultEnum.CUSTOM_ERROR;
/**
* @Author small
* @Date 2023/5/23 19:25
* @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/payment/filter/AuthFilter.java 0 → 100644
package com.mmc.payment.filter;
/**
* @Author small
* @Date 2023/5/29 10:36
* @Version 1.0
*/
import javax.servlet.Filter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/** 登录认证 */
public interface AuthFilter extends Filter {
/** 拦截前 */
public boolean before(HttpServletRequest request, HttpServletResponse response);
/** 通过拦截后 */
public boolean after();
}
src/main/java/com/mmc/payment/filter/AuthSignatureFilter.java 0 → 100644
package com.mmc.payment.filter;
import com.alibaba.fastjson2.JSON;
import com.mmc.payment.common.ResultBody;
import com.mmc.payment.common.ResultEnum;
import com.mmc.payment.common.Tenant;
import com.mmc.payment.config.Audience;
import com.mmc.payment.config.TenantContext;
import com.mmc.payment.model.dto.UserAccountDTO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @Author small
* @Date 2023/5/29 10:36
* @Version 1.0
*/
@Slf4j
@Component
@WebFilter(filterName = "AuthSignatureFilter", urlPatterns = "/*")
public class AuthSignatureFilter implements AuthFilter {
@Autowired
private Audience audience;
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 无需登录白名单
*/
private static final String[] IGNORE_URLS = {"/payment/swagger/swagger-resources","/payment/swagger/v2/api-docs","/payment/swagger/doc.html"};
/*无需加密狗无需登录白名单*/
private static final String[] USE_KEY = {"/crm/account/loginByUsbKey"};
/**
* 请求方式预请求方式值
*/
private static final String REQUEST_METHOD_OPTIONS_VALUE = "OPTIONS";
public static final String SWAGGER_URL_PREFIX = "/payment/swagger";
@Override
public void init(FilterConfig filterConfig) {
log.info(" filter name is 'AuthSignatureFilter' init success");
}
/**
* 过滤器前置处理
*
* @param request
* @param response
* @return
*/
@Override
public boolean before(HttpServletRequest request, HttpServletResponse response) {
String url = request.getRequestURI();
// 忽略以下url请求,白名单路径以及swagger路径
if (!ArrayUtils.contains(IGNORE_URLS, url)
&& !ArrayUtils.contains(USE_KEY, url) && !url.startsWith("/payment/webjars") && !url.startsWith(SWAGGER_URL_PREFIX)) {
if (REQUEST_METHOD_OPTIONS_VALUE.equals(request.getMethod())) {
response.setStatus(HttpServletResponse.SC_OK);
return false;
} else {
String token = request.getHeader("token");
if (null==token){
response(response, ResultBody.error(ResultEnum.THE_REQUEST_IS_NOT_AUTHENTICATED));
return false;
}
String s = stringRedisTemplate.opsForValue().get(token);
if (null==s){
response(response,ResultBody.error(ResultEnum.THE_TOKEN_IS_INVALID));
return false;
}
UserAccountDTO userAccountDTO = JSON.parseObject(s, UserAccountDTO.class);
try {
Tenant tenant = TenantContext.buildTenant(userAccountDTO.getAccountNo());
if (tenant!=null){
TenantContext.setTenant(tenant);
return true;
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
return true;
}
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
final HttpServletRequest request = (HttpServletRequest) req;
final HttpServletResponse response = (HttpServletResponse) res;
if (!before(request, response)) {
return;
}
chain.doFilter(req, res);
after();
}
/**
* 过滤器后置处理
*
* @return
*/
@Override
public boolean after() {
TenantContext.clear(); // 上下文清理
return true;
}
private static final String APPLICATION_JSON_UTF8 = "application/json;charset=UTF-8";
public static void response(HttpServletResponse response, ResultBody resultBody) {
response.setContentType(APPLICATION_JSON_UTF8);
try {
response
.getWriter()
.write(JSON.toJSONString(ResultBody.error(resultBody.getCode(), resultBody.getMessage())));
} catch (IOException e) {
log.error(e.getMessage());
}
}
private static String toString(Object obj) {
if (null == obj) {
return "";
}
return obj.toString();
}
@Override
public void destroy() {
}
}
src/main/java/com/mmc/payment/jwt/JwtConstant.java 0 → 100644
package com.mmc.payment.jwt;
/**
* @Author small
* @Date 2023/5/23 19:22
* @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/payment/model/dto/BaseAccountDTO.java 0 → 100644
package com.mmc.payment.model.dto;
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/23 19:15 @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;
@ApiModelProperty(value = "token")
private String token;
@ApiModelProperty(value = "账号id")
private Integer userAccountId;
@ApiModelProperty(value = "账号")
private String accountNo;
@ApiModelProperty(value = "账号uid")
private String uid;
@ApiModelProperty(value = "手机号")
private String phoneNum;
@ApiModelProperty(value = "用户名称")
private String userName;
@ApiModelProperty(value = "用户昵称")
private String nickName;
}
src/main/java/com/mmc/payment/model/dto/CompanyCacheDTO.java 0 → 100644
package com.mmc.payment.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/23 19:16
* @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/payment/model/dto/CompanySimpleDTO.java 0 → 100644
package com.mmc.payment.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 10:18
* @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/payment/model/dto/CurrentUserDTO.java 0 → 100644
package com.mmc.payment.model.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 9:55
* @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/payment/model/dto/ExpStationsDTO.java 0 → 100644
package com.mmc.payment.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;
/**
* @Author small
* @Date 2023/5/27 15:31
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.ExpStationsDTO", description = "物流信息DTO")
public class ExpStationsDTO implements Serializable {
private static final long serialVersionUID = 8737447241343561076L;
@ApiModelProperty(value = "物流状态：查字典")
private String Action;
@ApiModelProperty(value = "描述")
private String AcceptStation;
@ApiModelProperty(value = "时间")
private String AcceptTime;
@ApiModelProperty(value = "所在城市")
private String Location;
}
src/main/java/com/mmc/payment/model/dto/KdnExpDTO.java 0 → 100644
package com.mmc.payment.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/27 15:31
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.KdnExpDTO", description = "物流信息DTO")
public class KdnExpDTO implements Serializable {
private static final long serialVersionUID = 4129710329541565557L;
@ApiModelProperty(value = "物流状态：查字典")
private String StateEx;
@ApiModelProperty(value = "快递公司编码：查字典")
private String ShipperCode;
@ApiModelProperty(value = "物流单号")
private String LogisticCode;
@ApiModelProperty(value = "快递流转信息")
private List<ExpStationsDTO> Traces;
}
src/main/java/com/mmc/payment/model/dto/OrderInfoDTO.java 0 → 100644
package com.mmc.payment.model.dto;
import com.mmc.payment.entity.RepoCashDO;
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/27 15:16
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.OrderInfoDTO", description = "云仓订单DTO")
public class OrderInfoDTO implements Serializable {
private static final long serialVersionUID = 1572467108563651846L;
@ApiModelProperty(value = "ID")
private Integer id;
@ApiModelProperty(value = "订单编号")
private String orderNo;
@ApiModelProperty(value = "商品ID")
private Integer wareInfoId;
@ApiModelProperty(value = "商品编号")
private String wareNo;
@ApiModelProperty(value = "商品标题")
private String wareTitle;
@ApiModelProperty(value = "商品图片")
private String wareImg;
@ApiModelProperty(value = "套餐（sku）ID")
private Integer skuInfoId;
@ApiModelProperty(value = "套餐（sku）名称")
private String skuTitle;
@ApiModelProperty(value = "购买用户ID")
private Integer repoAccountId;
@ApiModelProperty(value = "用户UID")
private String uid;
@ApiModelProperty(value = "买家name")
private String buyerName;
@ApiModelProperty(value = "买家电话")
private String buyerPhone;
@ApiModelProperty(value = "单价")
private BigDecimal unitPrice;
@ApiModelProperty(value = "购买的商品数量")
private Integer wareNum;
@ApiModelProperty(value = "应付款金额")
private BigDecimal shouldPay;
@ApiModelProperty(value = "实收款金额")
private BigDecimal actualPay;
@ApiModelProperty(value = "订单类型：0租赁 100购买")
private Integer orderType;
@ApiModelProperty(value = "押金")
private BigDecimal deposit;
@ApiModelProperty(value = "租金总金额")
private BigDecimal rentPrice;
@ApiModelProperty(value = "租约开始日")
private Date startDate;
@ApiModelProperty(value = "租约结束日")
private Date endDate;
@ApiModelProperty(value = "付款天数")
private Integer payDay;
@ApiModelProperty(value = "交易状态：查订单状态字典")
private String tranStatus;
@ApiModelProperty(value = "减库方式 0:买家拍下减库存 1:卖家付款减库存")
private Integer exWare;
@ApiModelProperty(value = "用户备注")
private String remark;
@ApiModelProperty(value = "平台人员备注")
private String pfRemark;
@ApiModelProperty(value = "关闭原因")
private String shutReason;
@ApiModelProperty(value = "交易编号")
private String payNo;
@ApiModelProperty(value = "支付时间")
private Date payTime;
@ApiModelProperty(value = "发货时间")
private Date sendWareTime;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "物流信息/收货地址信息")
private OrderReceiptDTO receipt;
@ApiModelProperty(value = "退款单详情信息,无则为null")
private OrderRefundDTO orderRefund;
@ApiModelProperty(value = "发货-物流动态,无则为null")
private KdnExpDTO express;
@ApiModelProperty(value = "退货-物流动态,无则为null")
private KdnExpDTO refundExpress;
@ApiModelProperty(value = "质检详情,无则为null")
private List<OrderVcuDTO> vcus;
public RepoCashDO buildRepoCashDO() {
return RepoCashDO.builder().uid(this.uid).accountName(this.buyerName).orderInfoId(this.id)
.orderNo(this.orderNo).skuInfoId(this.skuInfoId).skuTitle(this.skuTitle).wareInfoId(this.wareInfoId)
.wareTitle(this.wareTitle).wareNo(this.wareNo).build();
}
}
src/main/java/com/mmc/payment/model/dto/OrderReceiptDTO.java 0 → 100644
package com.mmc.payment.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/27 15:27
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.OrderReceiptDTO", description = "订单收货信息DTO")
public class OrderReceiptDTO implements Serializable {
private static final long serialVersionUID = -6212026509857770276L;
@ApiModelProperty(value = "地址ID")
private Integer id;
@ApiModelProperty(value = "收货方式：0邮寄 1门店地址")
private Integer receiptMethod;
@ApiModelProperty(value = "0-收货人姓名")
private String takeName;
@ApiModelProperty(value = "0-收货人电话")
private String takePhone;
@ApiModelProperty(value = "0-收货区域")
private String region;
@ApiModelProperty(value = "0-收获详细地址")
private String detailAddress;
@ApiModelProperty(value = "1-门店名称")
private String repoName;
@ApiModelProperty(value = "1-门店详细地址")
private String repoAddress;
@ApiModelProperty(value = "1-预留手机号")
private String bookPhone;
@ApiModelProperty(value = "发货-物流公司码")
private String sendExCode;
@ApiModelProperty(value = "发货-物流单号")
private String sendExNo;
@ApiModelProperty(value = "发货地址")
private String sendAddress;
@ApiModelProperty(value = "退还货方式：0邮寄 1门店地址")
private Integer renMethod;
@ApiModelProperty(value = "退还货-收货电话")
private String renPhone;
@ApiModelProperty(value = "退还货-收货人")
private String renName;
@ApiModelProperty(value = "退还货-物流公司码")
private String renExCode;
@ApiModelProperty(value = "退还货-物流单号")
private String renExNo;
@ApiModelProperty(value = "退还货-地址")
private String renAddress;
@ApiModelProperty(value = "退还货-门店名称")
private String renRepoName;
@ApiModelProperty(value = "退还货-门店地址")
private String renRepoAddr;
@ApiModelProperty(value = "退还货-门店联系电话")
private String renRepoPhone;
}
src/main/java/com/mmc/payment/model/dto/OrderRefundDTO.java 0 → 100644
package com.mmc.payment.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/27 15:27
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "com.mmc.csf.model.dto.OrderRefundDTO", description = "退款单DTO")
public class OrderRefundDTO implements Serializable {
private static final long serialVersionUID = -6124933008580173589L;
@ApiModelProperty(value = "退款单ID")
private Integer id;
@ApiModelProperty(value = "订单ID")
private Integer orderInfoId;
@ApiModelProperty(value = "退款单号")
private String refundNo;
@ApiModelProperty(value = "退款单状态：查字典")
private Integer refundStatus;
@ApiModelProperty(value = "应退款金额")
private BigDecimal shouldRefund;
@ApiModelProperty(value = "实际退款金额")
private BigDecimal actualRefund;
@ApiModelProperty(value = "退款理由")
private String reason;
@ApiModelProperty(value = "创建时间/申请时间")
private Date createTime;
@ApiModelProperty(value = "退款-设备情况(图片&视频)")
private OrderVcuDTO orderVcu;
@ApiModelProperty(value = "订单信息")
private OrderInfoDTO orderInfo;
@ApiModelProperty(value = "退款协商历史")
private List<RefundLogDTO> rlogs;
@ApiModelProperty(value = "退款流水信息")
private RepoCashDTO refundCash;
@ApiModelProperty(value = "平台备注")
private String pfRemark;
}
src/main/java/com/mmc/payment/model/dto/OrderVcuDTO.java 0 → 100644
package com.mmc.payment.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/27 15:27
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "com.mmc.csf.model.dto.OrderVcuDTO", description = "订单凭证DTO")
public class OrderVcuDTO implements Serializable {
private static final long serialVersionUID = -7101242524092899210L;
@ApiModelProperty(value = "ID")
private Integer id;
@ApiModelProperty(value = "订单ID")
private Integer orderInfoId;
@ApiModelProperty(value = "0:发货 1:收货 2:归还 3:平台收货")
private Integer vcuType;
@ApiModelProperty(value = "设备状况:0无问题 1有问题")
private Integer vcuSatus;
@ApiModelProperty(value = "描述-备注")
private String remark;
@ApiModelProperty(value = "图片集合")
private List<String> imgs;
@ApiModelProperty(value = "视频")
private String videoUrl;
}
src/main/java/com/mmc/payment/model/dto/PayCashResultDTO.java 0 → 100644
package com.mmc.payment.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;
/**
* @Author small
* @Date 2023/5/27 15:22
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.PayCashResultDTO", description = "云仓支付扣款DTO")
public class PayCashResultDTO implements Serializable {
private static final long serialVersionUID = 5187623898281150213L;
@ApiModelProperty(value = "响应状态（200成功，其他失败）")
private String status;
@ApiModelProperty(value = "响应消息")
private String message;
@ApiModelProperty(value = "交易编号")
private String payNo;
@ApiModelProperty(value = "本次操作支付现金金额")
private BigDecimal cashPaid;
public static PayCashResultDTO error(String status, String message) {
return PayCashResultDTO.builder().status(status).message(message).build();
}
public static PayCashResultDTO success(BigDecimal cashPaid, String payNo) {
return PayCashResultDTO.builder().status("200").message("success").cashPaid(cashPaid).payNo(payNo).build();
}
}
src/main/java/com/mmc/payment/model/dto/RefundLogDTO.java 0 → 100644
package com.mmc.payment.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/27 15:30
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.RefundLogDTO", description = "退款logDTO")
public class RefundLogDTO implements Serializable {
private static final long serialVersionUID = 6524395508534109389L;
@ApiModelProperty(value = "内容")
private String msg;
@ApiModelProperty(value = "账号")
private String opAccount;
@ApiModelProperty(value = "名称")
private String opName;
@ApiModelProperty(value = "创建/发送时间")
private Date createTime;
}
src/main/java/com/mmc/payment/model/dto/RepoAccountDTO.java 0 → 100644
package com.mmc.payment.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/23 19:13
* @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/payment/model/dto/RepoCashDTO.java 0 → 100644
package com.mmc.payment.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 9:56
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.RepoBannerDTO", description = "现金流水DTO")
public class RepoCashDTO implements Serializable {
private static final long serialVersionUID = 4569221850373256579L;
@ApiModelProperty(value = "ID")
private Integer id;
@ApiModelProperty(value = "用户ID", hidden = true)
private Integer repoAccountId;
@ApiModelProperty(value = "用户UID", hidden = true)
private String uid;
@ApiModelProperty(value = "用户名", hidden = true)
private String accountName;
@ApiModelProperty(value = "订单ID", hidden = true)
private Integer orderInfoId;
@ApiModelProperty(value = "订单编号")
private String orderNo;
@ApiModelProperty(value = "skuID", hidden = true)
private Integer skuInfoId;
@ApiModelProperty(value = "sku标题", hidden = true)
private String skuTitle;
@ApiModelProperty(value = "商品ID", hidden = true)
private Integer wareInfoId;
@ApiModelProperty(value = "商品编号", hidden = true)
private String wareNo;
@ApiModelProperty(value = "商品标题")
private String wareTitle;
@ApiModelProperty(value = "流水编号")
private String payNo;
@ApiModelProperty(value = "流水类型:查字典")
private Integer payMethod;
@ApiModelProperty(value = "变动金额")
private BigDecimal amtPaid;
@ApiModelProperty(value = "当前余额")
private BigDecimal cashAmt;
@ApiModelProperty(value = "支付时间")
private Date payTime;
@ApiModelProperty(value = "退款流水编号")
private String refundNo;
@ApiModelProperty(value = "凭证")
private List<String> voucher;
@ApiModelProperty(value = "备注")
private String remark;
@ApiModelProperty(value = "操作人账号")
private String opNo;
@ApiModelProperty(value = "操作人姓名")
private String opName;
private Integer createUser;
}
src/main/java/com/mmc/payment/model/dto/RepoRcdTeamDTO.java 0 → 100644
package com.mmc.payment.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/23 20:01
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
//@ApiModel(value = "com.mmc.csf.model.dto.RepoRcdTeamDTO", description = "云仓推荐团队DTO")
public class RepoRcdTeamDTO implements Serializable {
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "账户名称")
private String RepoAccountName;
@ApiModelProperty(value = "uid")
private String uid;
@ApiModelProperty(value = "手机号")
private String phoneNum;
@ApiModelProperty(value = "发展时间")
private Date createTime;
@ApiModelProperty(value = "昵称")
private String nickName;
@ApiModelProperty(value = "企业认证状态：0未认证1已认证")
private Integer entAuthStatus;
@ApiModelProperty(value = "实名认证：0未实名1已实名2未通过")
private Integer realAuthStatus;
@ApiModelProperty(value = "账户类型 0游客1普通用户")
private Integer accountType;
@ApiModelProperty(value = "备注")
private String remark;
@ApiModelProperty(value = "entName")
private String entName;
}
src/main/java/com/mmc/payment/model/dto/RepoRebateWalletDTO.java 0 → 100644
package com.mmc.payment.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;
/**
* @Author small
* @Date 2023/5/23 20:01
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.RepoRebateWalletDTO", description = "奖励管理DTO")
public class RepoRebateWalletDTO implements Serializable {
private static final long serialVersionUID = 4874698532029550117L;
@ApiModelProperty(value = "UID")
private String uid;
@ApiModelProperty(value = "用户ID")
private Integer repoAccountId;
@ApiModelProperty(value = "昵称")
private String nickName;
@ApiModelProperty(value = "可提现-奖励金余额")
private BigDecimal rcdRebateAmt;
@ApiModelProperty(value = "提现中(冻结中)金额")
private BigDecimal rebateFreeze;
@ApiModelProperty(value = "已提现金额")
private BigDecimal rebateWdl;
@ApiModelProperty(value = "累计总额")
private BigDecimal totalRebate;
@ApiModelProperty(value = "团队人数")
private Integer teamUserNum;
public void computerTotalRebate() {
this.totalRebate = BigDecimal.ZERO;
if (this.rcdRebateAmt != null && this.rcdRebateAmt.compareTo(BigDecimal.ZERO) > 0) {
this.totalRebate = this.totalRebate.add(rcdRebateAmt);
}
if (this.rebateFreeze != null && this.rebateFreeze.compareTo(BigDecimal.ZERO) > 0) {
this.totalRebate = this.totalRebate.add(rebateFreeze);
}
if (this.rebateWdl != null && this.rebateWdl.compareTo(BigDecimal.ZERO) > 0) {
this.totalRebate = this.totalRebate.add(rebateWdl);
}
this.totalRebate = this.totalRebate.setScale(2, BigDecimal.ROUND_DOWN);
}
public void defaultValue() {
this.rcdRebateAmt = this.rcdRebateAmt == null ? BigDecimal.ZERO : this.rcdRebateAmt;
this.rebateFreeze = this.rebateFreeze == null ? BigDecimal.ZERO : this.rebateFreeze;
this.rebateWdl = this.rebateWdl == null ? BigDecimal.ZERO : this.rebateWdl;
this.totalRebate = this.totalRebate == null ? BigDecimal.ZERO : this.totalRebate;
}
}
src/main/java/com/mmc/payment/model/dto/RepoWalletDTO.java 0 → 100644
package com.mmc.payment.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;
/**
* @Author small
* @Date 2023/5/23 19:35
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.RepoWalletDTO", description = "钱包DTO")
public class RepoWalletDTO implements Serializable {
private static final long serialVersionUID = 5306992787421065922L;
@ApiModelProperty(value = "ID")
private Integer id;
@ApiModelProperty(value = "用户ID")
private Integer repoAccountId;
@ApiModelProperty(value = "现金余额")
private BigDecimal cashAmt;
@ApiModelProperty(value = "已付金额")
private BigDecimal cashPaid;
@ApiModelProperty(value = "冻结中-金额")
private BigDecimal cashFreeze;
@ApiModelProperty(value = "奖励-余额")
private BigDecimal rcdRebateAmt;
@ApiModelProperty(value = "累计提现")
private BigDecimal rebateWdl;
@ApiModelProperty(value = "提现冻结金额")
private BigDecimal rebateFreeze;
@ApiModelProperty(value = "平台备注")
private String remark;
public void defaultRebateValue() {
if (this.rcdRebateAmt == null) {
this.rcdRebateAmt = BigDecimal.ZERO;
}
if (this.rebateWdl == null) {
this.rebateWdl = BigDecimal.ZERO;
}
}
}
src/main/java/com/mmc/payment/model/dto/RoleInfoDTO.java 0 → 100644
package com.mmc.payment.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 10:19
* @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/payment/model/dto/UserAccountDTO.java 0 → 100644
package com.mmc.payment.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 10:18
* @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/payment/model/dto/UserAccountSimpleDTO.java 0 → 100644
package com.mmc.payment.model.dto;
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/25 17:50
* @Version 1.0
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class UserAccountSimpleDTO implements Serializable {
private static final long serialVersionUID = 3451336520607073343L;
@ApiModelProperty(value = "用户id")
private Integer id;
@ApiModelProperty(value = "用户类型")
private Integer accountType;
@ApiModelProperty(value = "用户uid")
private String uid;
@ApiModelProperty(value = "手机号")
private String phoneNum;
@ApiModelProperty(value = "用户名称")
private String userName;
@ApiModelProperty(value = "用户昵称")
private String nickName;
@ApiModelProperty(value = "用户头像")
private String userImg;
@ApiModelProperty(value = "用户性别：0未知、1男、2女")
private Integer userSex;
@ApiModelProperty(value = "用户邮箱")
private String email;
@ApiModelProperty(value = "用户来源，0自然流、1海报、2抖音、3公众号、4社群、5招投标、6官网")
private Integer source;
@ApiModelProperty(value = "用户可用状态：0禁用、1可用")
private Integer accountStatus;
@ApiModelProperty(value = "账号类型：0后台管理账号 ; 100云享飞-客户端;")
private Integer portType;
@ApiModelProperty(value = "企业认证状态, 0未通过，1通过")
private Integer companyAuthStatus;
}
src/main/java/com/mmc/payment/model/qo/BaseInfoQO.java 0 → 100644
package com.mmc.payment.model.qo;
import com.mmc.payment.common.Freeze;
import com.mmc.payment.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/23 19:18
* @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/payment/model/qo/RepoAccountQO.java 0 → 100644
package com.mmc.payment.model.qo;
import com.mmc.payment.common.Page;
import com.mmc.payment.config.UserPorts;
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 javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
/**
* @Author small
* @Date 2023/5/23 19:13
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.qo.RepoAccountQO", description = "云仓账号信息查询QO")
public class RepoAccountQO implements Serializable {
private static final long serialVersionUID = -3425378226992206841L;
@ApiModelProperty(value = "关键字")
private String keyword;
@ApiModelProperty(value = "实名认证状态")
private Integer realAuthStatus;
@ApiModelProperty(value = "企业认证状态")
private Integer entAuthStatus;
@ApiModelProperty(value = "用户类型")
private Integer accountType;
@ApiModelProperty(value = "注册开始时间")
private Date startTime;
@ApiModelProperty(value = "注册结束时间")
private Date endTime;
@ApiModelProperty(value = "是否渠道")
private Integer channelAuthStatus;
@ApiModelProperty(value = "渠道等级")
private Integer channelClass;
@ApiModelProperty(value = "是否销售")
private Integer sale;
@ApiModelProperty(value = "是否白名单")
private Integer white;
@ApiModelProperty(value = "用户来源：0自然流，1海报，2抖音，3公众号，4社群，5招投标，默认0")
private Integer source;
@ApiModelProperty(value = "用户ID", hidden = true)
private List<Integer> accountIds;
@ApiModelProperty(value = "多端用户，USER_PORT(云享飞)-FLYER_PORT(云飞手)-REPO_PORT(云仓)")
private Set<String> ports;
@ApiModelProperty(value = "多端用户（差集），USER_PORT(云享飞)-FLYER_PORT(云飞手)-REPO_PORT(云仓)", hidden = true)
private Set<String> eports;
@ApiModelProperty(value = "推荐单位ID")
private Integer rcdCompanyId;
@ApiModelProperty(value = "单位ID", hidden = true)
private List<Integer> companys;
@ApiModelProperty(value = "页码", required = true)
@NotNull(message = "页码不能为空", groups = Page.class)
@Min(value = 1, groups = Page.class)
private Integer pageNo;
@ApiModelProperty(value = "每页显示数", required = true)
@NotNull(message = "每页显示数不能为空", groups = Page.class)
@Min(value = 1, groups = Page.class)
private Integer pageSize;
public void buildCurrentPage() {
this.pageNo = (pageNo - 1) * pageSize;
}
public void buildEports() {
if (!CollectionUtils.isEmpty(this.ports)) {
this.eports = UserPorts.ports.stream().filter(d -> !this.ports.contains(d)).collect(Collectors.toSet());
}
}
}
src/main/java/com/mmc/payment/model/qo/RepoCashQO.java 0 → 100644
package com.mmc.payment.model.qo;
import com.mmc.payment.common.Page;
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.Min;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
/**
* @Author small
* @Date 2023/5/24 9:56
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.qo.RepoCashQO", description = "现金变更QO")
public class RepoCashQO implements Serializable {
private static final long serialVersionUID = 8705749845968042632L;
@ApiModelProperty(value = "用户ID")
@NotNull(message = "用户ID不能为空", groups = Page.class)
private Integer repoAccountId;
@ApiModelProperty(value = "关键字")
private String keyword;
@ApiModelProperty(value = "开始时间")
private String startTime;
@ApiModelProperty(value = "结束时间")
private String endTime;
@ApiModelProperty(value = "交易类型：查字典")
private Integer payMethod;
@ApiModelProperty(value = "页码", required = true)
@NotNull(message = "页码不能为空", groups = Page.class)
@Min(value = 1, groups = Page.class)
private Integer pageNo;
@ApiModelProperty(value = "每页显示数", required = true)
@NotNull(message = "每页显示数不能为空", groups = Page.class)
@Min(value = 1, groups = Page.class)
private Integer pageSize;
public void buildCurrentPage() {
this.pageNo = (pageNo - 1) * pageSize;
}
}
src/main/java/com/mmc/payment/model/qo/UserAccountQO.java 0 → 100644
package com.mmc.payment.model.qo;
import com.mmc.payment.common.Page;
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.Min;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.List;
/**
* @Author small
* @Date 2023/5/24 10:18
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.qo.UserAccountQO", description = "账号查询条件封装类")
public class UserAccountQO implements Serializable {
private static final long serialVersionUID = -2780882438255193738L;
@ApiModelProperty(value = "关键字", required = false)
private String keyword;
@ApiModelProperty(value = "地区", required = false)
private String area;
@ApiModelProperty(value = "角色id", required = false)
private Integer roleId;
@ApiModelProperty(value = "账号状态：0禁用 1可用")
private Integer accountStatus;
@ApiModelProperty(value = "账号状态：0合伙人 1员工")
private Integer userType;
@ApiModelProperty(value = "用户id集合")
private List<Integer> userIds;
@ApiModelProperty(value = "推荐单位id")
private Integer rcdCompanyId;
@ApiModelProperty(value="单位集合", hidden = true)
private List<Integer> companys;
@ApiModelProperty(value = "页码", required = true)
@NotNull(message = "页码不能为空", groups = Page.class)
@Min(value = 1, groups = Page.class)
private Integer pageNo;
@ApiModelProperty(value = "每页显示数", required = true)
@NotNull(message = "每页显示数不能为空", groups = Page.class)
@Min(value = 1, groups = Page.class)
private Integer pageSize;
public void buildCurrentPage() {
this.pageNo = (pageNo - 1) * pageSize;
}
}
src/main/java/com/mmc/payment/model/vo/RepoAccountVO.java 0 → 100644
package com.mmc.payment.model.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.ibatis.annotations.Update;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @Author small
* @Date 2023/5/23 19:39
* @Version 1.0
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.vo.RepoAccountVO", description = "微信用户信息修改VO")
public class RepoAccountVO implements Serializable {
private static final long serialVersionUID = -2060063935512185318L;
@ApiModelProperty(value = "repoAccountId")
@NotNull(message = "repoAccountId不能为空", groups = Update.class)
private Integer id;
@ApiModelProperty(value = "nickName")
private String nickName;
@ApiModelProperty(value = "常驻地址")
private String resAddress;
@ApiModelProperty(value = "经度")
private BigDecimal lon;
@ApiModelProperty(value = "纬度")
private BigDecimal lat;
@ApiModelProperty(value = "头像")
private String headerImg;
}
src/main/java/com/mmc/payment/model/vo/RepoCashVO.java 0 → 100644
package com.mmc.payment.model.vo;
import com.mmc.payment.common.Create;
import com.mmc.payment.common.Refund;
import com.mmc.payment.common.Share;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.List;
/**
* @Author small @Date 2023/5/24 10:04 @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
// @ApiModel(value = "com.mmc.csf.model.vo.RepoCashVO", description = "现金变更VO")
public class RepoCashVO implements Serializable {
private static final long serialVersionUID = 1828354753495845609L;
/* @ApiModelProperty(value = "用户ID")
@NotNull(
message = "用户ID不能为空",
groups = {Create.class})
private Integer repoAccountId;*/
/* @ApiModelProperty(value = "订单ID")
@NotNull(
message = "orderRefundId不能为空",
groups = {Refund.class})
private Integer orderRefundId;
@ApiModelProperty(value = "返租订单ID")
@NotNull(
message = "shareOrderId不能为空",
groups = {Share.class})
private Integer shareOrderId;*/
@ApiModelProperty(value = "变动金额")
@NotNull(
message = "变动金额不能为空",
groups = {Create.class, Refund.class})
private BigDecimal amtPaid;
@ApiModelProperty(value = "凭证图片集合")
private List<String> voucher;
@ApiModelProperty(value = "备注")
private String remark;
@ApiModelProperty(value = "操作人员密码")
@NotNull(
message = "变动金额不能为空",
groups = {Refund.class, Share.class})
private String authPwd;
}
src/main/java/com/mmc/payment/model/vo/RepoOrderPayVO.java 0 → 100644
package com.mmc.payment.model.vo;
import com.mmc.payment.model.dto.BaseAccountDTO;
import com.mmc.payment.model.dto.OrderInfoDTO;
import com.mmc.payment.model.dto.RepoAccountDTO;
import io.swagger.annotations.ApiModel;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @Author small
* @Date 2023/5/27 15:23
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.vo.RepoOrderPayVO", description = "订单支付VO")
public class RepoOrderPayVO implements Serializable {
private static final long serialVersionUID = 8149373745729826654L;
private BaseAccountDTO account;
private OrderInfoDTO orderInfo;
private ShareOrderDTO shareOrder;
private RepoAccountDTO repoAccount;
private RepoCashVO payCash;
private BigDecimal amtPaid;
private String refundNo;
}
src/main/java/com/mmc/payment/model/vo/ShareOrderDTO.java 0 → 100644
package com.mmc.payment.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.Date;
/**
* @Author small
* @Date 2023/5/27 15:23
* @Version 1.0
*/
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
//@ApiModel(value = "com.mmc.csf.model.dto.ShareOrderDTO", description = "共享设备订单DTO")
public class ShareOrderDTO implements Serializable {
private static final long serialVersionUID = -1395178773843809078L;
@ApiModelProperty(value = "id")
private Integer id;
@ApiModelProperty(value = "订单编号")
private String orderNo;
@ApiModelProperty(value = "用户id")
private Integer repoAccountId;
@ApiModelProperty(value = "用户uid")
private String uid;
@ApiModelProperty(value = "用户手机号")
private String phoneNum;
@ApiModelProperty(value = "设备品牌")
private String deviceBrand;
@ApiModelProperty(value = "地区")
private String region;
@ApiModelProperty(value = "状态:查字典")
private Integer sdStatus;
@ApiModelProperty(value = "设备ID")
private String deviceCode;
@ApiModelProperty(value = "设备型号")
private String deviceModel;
@ApiModelProperty(value = "用户备注")
private String remark;
@ApiModelProperty(value = "平台备注")
private String pfRemark;
@ApiModelProperty(value = "创建时间")
private Date createTime;
@ApiModelProperty(value = "修改人ID", hidden = true)
private Integer updateUser;
@ApiModelProperty(value = "操作人-名字")
private String opName;
@ApiModelProperty(value = "操作人-账号")
private String opNo;
}
src/main/java/com/mmc/payment/service/Impl/RepoAccountServiceImpl.java 0 → 100644
package com.mmc.payment.service.Impl;
import com.mmc.payment.common.PageResult;
import com.mmc.payment.dao.RepoAccountDao;
import com.mmc.payment.entity.RepoWalletDO;
import com.mmc.payment.model.dto.BaseAccountDTO;
import com.mmc.payment.model.dto.RepoAccountDTO;
import com.mmc.payment.model.dto.RepoWalletDTO;
import com.mmc.payment.model.qo.RepoAccountQO;
import com.mmc.payment.service.RepoAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @Author small @Date 2023/5/23 19:12 @Version 1.0
*/
@Service
public class RepoAccountServiceImpl implements RepoAccountService {
@Autowired private RepoAccountDao repoAccountDao;
@Override
public PageResult listPagePayManager(RepoAccountQO param, BaseAccountDTO cuser) {
/*if(!cuser.isManage()){
param.setCompanys(cuser.getCompanyInfo().getCompanys());
}*/
int count = repoAccountDao.countPagePayManager(param);
if (count == 0) {
return PageResult.buildPage(param.getPageNo(), param.getPageSize(), count);
}
Integer pageNo = param.getPageNo();
param.buildCurrentPage();
List<RepoAccountDTO> data =
repoAccountDao.listPagePayManager(param).stream()
.map(
d -> {
d.buildName();
return d.buildRepoAccountDTO();
})
.collect(Collectors.toList());
List<Integer> accountIds =
data.stream().map(RepoAccountDTO::getId).collect(Collectors.toList());
param.setAccountIds(accountIds);
// List<RepoWalletDTO> wallets = repoPayServletClient.feignListWalletInfo(param);
List<RepoWalletDTO> wallets = listWalletInfo(param);
Map<Integer, RepoWalletDTO> mapWallet =
wallets.stream()
.collect(
Collectors.toMap(
RepoWalletDTO::getRepoAccountId, wallet -> wallet, (k1, k2) -> k2));
for (RepoAccountDTO ac : data) {
if (mapWallet.containsKey(ac.getId())) {
ac.setCashAmt(mapWallet.get(ac.getId()).getCashAmt());
ac.setRemark(mapWallet.get(ac.getId()).getRemark());
}
}
return PageResult.buildPage(pageNo, param.getPageSize(), count, data);
}
public List<RepoWalletDTO> listWalletInfo(RepoAccountQO param) {
if (CollectionUtils.isEmpty(param.getAccountIds())) {
return java.util.Collections.emptyList();
}
List<RepoWalletDO> wallets = repoAccountDao.listWalletInfo(param);
return wallets.stream()
.map(
d -> {
return d.buildRepoWalletDTO();
})
.collect(Collectors.toList());
}
}
src/main/java/com/mmc/payment/service/Impl/RepoCashServiceImpl.java 0 → 100644
package com.mmc.payment.service.Impl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.mmc.payment.common.*;
import com.mmc.payment.config.RepoCashMethod;
import com.mmc.payment.dao.RepoCashDao;
import com.mmc.payment.entity.RepoCashDO;
import com.mmc.payment.entity.RepoWalletDO;
import com.mmc.payment.model.dto.*;
import com.mmc.payment.model.qo.RepoCashQO;
import com.mmc.payment.model.qo.UserAccountQO;
import com.mmc.payment.model.vo.RepoCashVO;
import com.mmc.payment.model.vo.RepoOrderPayVO;
import com.mmc.payment.service.RepoCashService;
import io.jsonwebtoken.lang.Collections;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @Author small @Date 2023/5/24 10:06 @Version 1.0
*/
@Service
public class RepoCashServiceImpl implements RepoCashService {
@Autowired private RepoCashDao repoCashDao;
@Autowired private RestTemplate restTemplate;
@Autowired private StringRedisTemplate stringRedisTemplate;
/* @Autowired
private RepoWalletDao repoWalletDao;*/
/*@Autowired
private UserServletClient userServletClient;
@Autowired
private RepoServletClient repoServletClient;*/
@Value("${userapp.url}")
private String userAppUrl;
@Override
public PageResult listPageRepoCash(RepoCashQO param) {
int count = repoCashDao.countPagePFRepoCash(param);
if (count == 0) {
return PageResult.buildPage(param.getPageNo(), param.getPageSize(), count);
}
Integer pageNo = param.getPageNo();
param.buildCurrentPage();
List<RepoCashDO> list = repoCashDao.listPagePFRepoCash(param);
List<Integer> userIds = new ArrayList<Integer>();
for (RepoCashDO d : list) {
if (d.getCreateUser() != null && !userIds.contains(d.getCreateUser())) {
userIds.add(d.getCreateUser());
}
}
List<RepoCashDTO> data =
list.stream()
.map(
d -> {
return d.buildRepoCashDTO();
})
.collect(Collectors.toList());
UserAccountQO uq = UserAccountQO.builder().userIds(userIds).build();
List<UserAccountDTO> users = null;
// 批量获取用户信息
// userServletClient.feignListUserAccountById(uq);
// 远程调用非当前接口
ResponseEntity<String> response =
restTemplate.getForEntity(
"http://localhost:35150/userapp/user-account/feignGetUserSimpleInfo?userAccountId=1"
+ userIds,
String.class);
String body = response.getBody();
Map<Integer, UserAccountDTO> mapUser =
users.stream().collect(Collectors.toMap(UserAccountDTO::getId, ud -> ud, (k1, k2) -> k2));
data.forEach(
d -> {
if (mapUser.containsKey(d.getCreateUser())) {
d.setOpNo(mapUser.get(d.getCreateUser()).getAccountNo());
d.setOpName(mapUser.get(d.getCreateUser()).getUserName());
}
});
return PageResult.buildPage(pageNo, param.getPageSize(), count, data);
}
@Override
public void updateCashRemark(Integer id, String remark) {
repoCashDao.updateCashRemark(id, remark);
}
@Override
public ResultBody reqCash(BaseAccountDTO cuser, RepoCashVO cash) {
// 金额范围验证
if (!AmtUtil.vertifyRepoAmt(cash.getAmtPaid())) {
return ResultBody.error(ResultEnum.AMT_PAID_VERITY_ERROR);
}
// 密码认证
// getResultBody(cuser, cash);
// 用户信息
// RepoAccountDTO account = null;
// repoServletClient.feignAccountSimpleInfo(cash.getRepoAccountId());
ResponseEntity<String> response =
restTemplate.getForEntity(
userAppUrl
+ "user-account/feignGetUserSimpleInfo?userAccountId="
+ cuser.getUserAccountId(),
String.class);
UserAccountSimpleDTO account = JSON.parseObject(response.getBody(), UserAccountSimpleDTO.class);
if (account == null) {
return ResultBody.error(ResultEnum.FEIGN_REPOUSER_SERVLET_ERROR);
}
RepoWalletDO wallet = repoCashDao.getRepoWalletInfo(cuser.getUserAccountId());
if (wallet == null) {
return ResultBody.error(ResultEnum.WALLET_NOT_FIND_ERROR);
}
// 扣除的金额不能大于余额
if (cash.getAmtPaid().compareTo(wallet.getCashAmt()) > 0) {
return ResultBody.error(ResultEnum.WALLET_CASH_NOT_ENOUGH_ERROR);
}
Date cdate = new Date();
RepoCashDO rc = new RepoCashDO();
rc.setRepoAccountId(account.getId());
rc.setUid(account.getUid());
rc.setAccountName(account.getUserName());
rc.setPayNo(CodeUtil.createRepoCashNo());
rc.setPayMethod(RepoCashMethod.REG.getCode());
rc.setAmtPaid(cash.getAmtPaid());
BigDecimal newCashAmt =
(wallet.getCashAmt().add(cash.getAmtPaid())).setScale(2, BigDecimal.ROUND_DOWN);
rc.setCashAmt(newCashAmt);
rc.setPayTime(cdate);
String voucher =
Collections.isEmpty(cash.getVoucher()) ? null : String.join(",", cash.getVoucher());
rc.setVoucher(voucher);
rc.setRemark(cash.getRemark());
rc.setCreateTime(cdate);
rc.setCreateUser(cuser.getUserAccountId());
repoCashDao.insertRepoCash(rc);
repoCashDao.updateRepoWalletAmt(account.getId(), rc.getAmtPaid());
return ResultBody.success();
}
/* private String getResultBody(BaseAccountDTO cuser, RepoCashVO cash) {
ResponseEntity<String> response =
restTemplate.getForEntity(
userAppUrl
+ "back-user/feignAuthUserPwd?authPwd="
+ cash.getAuthPwd()
+ "&id="
+ +cuser.getUserAccountId(),
String.class);
ResultBody body = JSON.parseObject(response.getBody(), ResultBody.class);
*/
/* if (!ResultEnum.SUCCESS.getResultCode().equals(body.getCode())) {
return body;
}*/
/*
}*/
@Override
public ResultBody dedCash(BaseAccountDTO cuser, RepoCashVO cash) {
// 金额范围验证
if (!AmtUtil.vertifyRepoAmt(cash.getAmtPaid())) {
return ResultBody.error(ResultEnum.AMT_PAID_VERITY_ERROR);
}
// 密码认证
ResultBody body = null;
// userServletClient.feignAuthUserPwd(cuser.getId(), cash.getAuthPwd());
/*if (!ResultEnum.SUCCESS.getResultCode().equals(body.getCode())) {
return body;
}*/
// 用户信息
// RepoAccountDTO account =null;
// repoServletClient.feignAccountSimpleInfo(cash.getRepoAccountId());
ResponseEntity<String> response =
restTemplate.getForEntity(
userAppUrl
+ "user-account/feignGetUserSimpleInfo?userAccountId="
+ cuser.getUserAccountId(),
String.class);
String body1 = response.getBody();
UserAccountSimpleDTO account = JSON.parseObject(body1, UserAccountSimpleDTO.class);
if (account == null) {
return ResultBody.error(ResultEnum.FEIGN_REPOUSER_SERVLET_ERROR);
}
RepoWalletDO wallet = repoCashDao.getRepoWalletInfo(cuser.getUserAccountId());
if (wallet == null) {
return ResultBody.error(ResultEnum.WALLET_NOT_FIND_ERROR);
}
// 扣除的金额不能大于余额
if (cash.getAmtPaid().compareTo(wallet.getCashAmt()) > 0) {
return ResultBody.error(ResultEnum.WALLET_CASH_NOT_ENOUGH_ERROR);
}
Date cdate = new Date();
RepoCashDO rc = new RepoCashDO();
rc.setRepoAccountId(account.getId());
rc.setUid(account.getUid());
rc.setAccountName(account.getUserName());
rc.setPayNo(CodeUtil.createRepoCashNo());
rc.setPayMethod(RepoCashMethod.HANDLER.getCode());
rc.setAmtPaid(cash.getAmtPaid().multiply(BigDecimal.valueOf(-1)));
BigDecimal newCashAmt =
(wallet.getCashAmt().subtract(cash.getAmtPaid())).setScale(2, BigDecimal.ROUND_DOWN);
rc.setCashAmt(newCashAmt);
rc.setPayTime(cdate);
String voucher =
Collections.isEmpty(cash.getVoucher()) ? null : String.join(",", cash.getVoucher());
rc.setVoucher(voucher);
rc.setRemark(cash.getRemark());
rc.setCreateTime(cdate);
rc.setCreateUser(cuser.getUserAccountId());
repoCashDao.insertRepoCash(rc);
repoCashDao.updateRepoWalletAmt(account.getId(), rc.getAmtPaid());
return ResultBody.success();
}
@Override
public RepoCashDTO getRefundInfo(String refundNo) {
RepoCashDO refund = repoCashDao.getRefundCashInfo(refundNo);
return refund == null ? null : refund.buildRepoCashDTO();
}
@Override
public BigDecimal RemainingBalance(Integer repoAccountId) {
return repoCashDao.RemainingBalance(repoAccountId);
}
@Override
public PayCashResultDTO orderPayment(BaseAccountDTO currentAccount, String orderNo) {
String s = stringRedisTemplate.opsForValue().get(orderNo);
RepoCashDO repoCashDO = JSONObject.parseObject(s, RepoCashDO.class);
repoCashDao.orderPayment(JSONObject.parseObject(s, RepoCashDO.class));
if (!currentAccount.getUserAccountId().equals(currentAccount.getUserAccountId())) {
return PayCashResultDTO.error(
ResultEnum.WALLET_NOT_FIND_ERROR.getResultCode(),
ResultEnum.WALLET_NOT_FIND_ERROR.getResultMsg());
}
return null;
}
@Override
public PayCashResultDTO payCashOrder(RepoOrderPayVO orderPay) {
BaseAccountDTO account = orderPay.getAccount();
OrderInfoDTO orderInfo = orderPay.getOrderInfo();
RepoWalletDO wallet = repoCashDao.getRepoWalletInfo(account.getUserAccountId());
if (wallet == null) {
return PayCashResultDTO.error(
ResultEnum.WALLET_NOT_FIND_ERROR.getResultCode(),
ResultEnum.WALLET_NOT_FIND_ERROR.getResultMsg());
}
BigDecimal amtPaid = orderInfo.getShouldPay();
if (amtPaid.compareTo(wallet.getCashAmt()) > 0) {
return PayCashResultDTO.error(
ResultEnum.WALLET_CASH_NOT_ENOUGH_ERROR.getResultCode(),
ResultEnum.WALLET_CASH_NOT_ENOUGH_ERROR.getResultMsg());
}
Date cdate = new Date();
RepoCashDO cash = orderInfo.buildRepoCashDO();
cash.setRepoAccountId(account.getUserAccountId());
cash.setPayNo(CodeUtil.createRepoCashNo());
cash.setPayMethod(RepoCashMethod.RENT.getCode());
cash.setAmtPaid(amtPaid.multiply(BigDecimal.valueOf(-1)));
cash.setCashAmt(wallet.getCashAmt().subtract(amtPaid));
cash.setPayTime(cdate);
cash.setCreateTime(cdate);
repoCashDao.insertRepoCash(cash);
repoCashDao.updateWalletAmt(account.getUserAccountId(), cash.getAmtPaid(), amtPaid);
return PayCashResultDTO.success(amtPaid, cash.getPayNo());
}
}
src/main/java/com/mmc/payment/service/RepoAccountService.java 0 → 100644
package com.mmc.payment.service;
import com.mmc.payment.common.PageResult;
import com.mmc.payment.model.dto.BaseAccountDTO;
import com.mmc.payment.model.qo.RepoAccountQO;
/**
* @Author small
* @Date 2023/5/23 19:10
* @Version 1.0
*/
public interface RepoAccountService {
PageResult listPagePayManager(RepoAccountQO param, BaseAccountDTO cuser);
}
src/main/java/com/mmc/payment/service/RepoCashService.java 0 → 100644
package com.mmc.payment.service;
import com.mmc.payment.common.PageResult;
import com.mmc.payment.common.ResultBody;
import com.mmc.payment.model.dto.BaseAccountDTO;
import com.mmc.payment.model.dto.PayCashResultDTO;
import com.mmc.payment.model.dto.RepoCashDTO;
import com.mmc.payment.model.qo.RepoCashQO;
import com.mmc.payment.model.vo.RepoCashVO;
import com.mmc.payment.model.vo.RepoOrderPayVO;
import java.math.BigDecimal;
/**
* @Author small @Date 2023/5/24 10:06 @Version 1.0
*/
public interface RepoCashService {
PageResult listPageRepoCash(RepoCashQO param);
void updateCashRemark(Integer id, String remark);
/**
* 充值
*
* @param cash
* @return
*/
ResultBody reqCash(BaseAccountDTO cuser, RepoCashVO cash);
ResultBody dedCash(BaseAccountDTO cuser, RepoCashVO cash);
RepoCashDTO getRefundInfo(String refundNo);
BigDecimal RemainingBalance(Integer uid);
PayCashResultDTO orderPayment(BaseAccountDTO currentAccount, String orderNo);
PayCashResultDTO payCashOrder(RepoOrderPayVO orderPay);
}
src/main/resources/application-dev.yml 0 → 100644
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://mysql.default:3306/iuav_payment?characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
username: tmj
password: MMC@2022&MYSQL
redis:
database: 1
host: redis.default
password: MMC@2022&REDIS
port: 6379
jedis:
pool:
max-active: 2
springfox:
documentation:
swagger-ui:
enabled: false
enabled: true #开启文档
aliyun:
oss:
endpoint: oss-cn-shenzhen.aliyuncs.com
access-key-id: LTAI4FzCpyrA33PegnxWS6XV
access-key-secret: ILuNh3zJfRjg3iARSipMWBKCjglz3u
bucket: pad-video-x
mmcflying:
download:
path: /ossservlet/upload/download/
mount:
directory: D:@javaVolume@
src/main/resources/application-local.yml 0 → 100644
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://rm-wz9dd796t4j1giz6t2o.mysql.rds.aliyuncs.com:3306/iuav_payment?characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
username: tmj
password: MMC@2022&MYSQL
redis:
database: 1
host: r-wz9ke310fs684hacn1pd.redis.rds.aliyuncs.com
port: 6379
password: MMC@2022&REDIS
jedis:
pool:
max-active: 2
springfox:
documentation:
swagger-ui:
enabled: false
enabled: true #开启文档
aliyun:
oss:
endpoint: oss-cn-shenzhen.aliyuncs.com
access-key-id: LTAI4FzCpyrA33PegnxWS6XV
access-key-secret: ILuNh3zJfRjg3iARSipMWBKCjglz3u
bucket: pad-video-x
mmcflying:
download:
path: /ossservlet/upload/download/
mount:
directory: D:@javaVolume@
userapp:
url: http://localhost:35150/userapp/
src/main/resources/application-prod.yml 0 → 100644
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://mysql.default:3306/iuav_payment?characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
username: tmj
password: MMC@2022&MYSQL
redis:
database: 1
host: redis.default
port: 6379
password: MMC@2022&REDIS
jedis:
pool:
max-active: 2
springfox:
documentation:
swagger-ui:
enabled: false
enabled: true #开启文档
aliyun:
oss:
endpoint: oss-cn-shenzhen.aliyuncs.com
access-key-id: LTAI4FzCpyrA33PegnxWS6XV
access-key-secret: ILuNh3zJfRjg3iARSipMWBKCjglz3u
bucket: pad-video-x
mmcflying:
download:
path: /ossservlet/upload/download/
mount:
directory: D:@javaVolume@
src/main/resources/application.yml 0 → 100644
server:
port: 8088
servlet:
context-path: /payment
spring:
profiles:
active: local
application:
name: payment
mvc:
async:
request-timeout: 600000
pathmatch:
matching-strategy: ANT_PATH_MATCHER
jackson:
date-format: yyyy-MM-dd HH:mm:ss
time-zone: GMT+8
logging:
level:
com:
mmc:
payment: DEBUG
src/main/resources/mapper/RepoAccountDao.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.payment.dao.RepoAccountDao">
<select id="listPagePayManager"></select>
</mapper>
src/main/resources/mapper/RepoCashDao.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.payment.dao.RepoCashDao">
<resultMap id="repoWalletResultMap"
type="com.mmc.payment.entity.RepoWalletDO">
<id property="id" column="id"/>
<result property="repoAccountId" column="repo_account_id"/>
<result property="cashAmt" column="cash_amt"/>
<result property="cashPaid" column="cash_paid"/>
<result property="cashFreeze" column="cash_freeze"/>
<result property="rcdRebateAmt" column="rcd_rebate_amt"/>
<result property="rebateWdl" column="rebate_wdl"/>
<result property="rebateFreeze" column="rebate_freeze"/>
<result property="remark" column="remark"/>
<result property="updateTime" column="create_time"/>
<result property="createTime" column="update_time"/>
</resultMap>
<resultMap id="repoCashResultMap"
type="com.mmc.payment.entity.RepoCashDO">
<id property="id" column="id"/>
<result property="repoAccountId" column="repo_account_id"/>
<result property="uid" column="uid"/>
<result property="accountName" column="account_name"/>
<result property="orderInfoId" column="order_info_id"/>
<result property="orderNo" column="order_no"/>
<result property="skuInfoId" column="sku_info_id"/>
<result property="skuTitle" column="sku_title"/>
<result property="wareInfoId" column="ware_info_id"/>
<result property="wareNo" column="ware_no"/>
<result property="wareTitle" column="ware_title"/>
<result property="payNo" column="pay_no"/>
<result property="payMethod" column="pay_method"/>
<result property="amtPaid" column="amt_paid"/>
<result property="cashAmt" column="cash_amt"/>
<result property="payTime" column="pay_time"/>
<result property="voucher" column="voucher"/>
<result property="refundNo" column="refund_no"/>
<result property="remark" column="remark"/>
<result property="updateTime" column="update_time"/>
<result property="updateUser" column="update_user"/>
<result property="createTime" column="create_time"/>
<result property="createUser" column="create_user"/>
</resultMap>
<select id="getRefundCashInfo" resultMap="repoCashResultMap"
parameterType="Integer">
select c.id,c.repo_account_id,c.ware_title,c.pay_no,
c.order_no,c.refund_no,c.create_user,c.pay_method,
c.amt_paid,c.cash_amt,c.remark,c.voucher,c.pay_time
from repo_cash c
<where>
c.refund_no = #{refundNo}
</where>
</select>
<insert id="insertRepoCash" useGeneratedKeys="true"
keyProperty="id" parameterType="com.mmc.payment.entity.RepoCashDO">
insert into repo_cash
(repo_account_id, uid, account_name, order_info_id, order_no, sku_info_id, sku_title,
ware_info_id, ware_no, ware_title, pay_no, pay_method, amt_paid, cash_amt, pay_time, remark,
voucher, refund_no, update_time, update_user, create_time, create_user)
values (#{repoAccountId}, #{uid}, #{accountName}, #{orderInfoId}, #{orderNo}, #{skuInfoId}, #{skuTitle},
#{wareInfoId}, #{wareNo}, #{wareTitle}, #{payNo}, #{payMethod}, #{amtPaid}, #{cashAmt}, #{payTime},
#{remark},
#{voucher}, #{refundNo}, #{updateTime}, #{updateUser}, #{createTime}, #{createUser})
</insert>
<update id="updateCashRemark">
update repo_cash
set remark = #{remark}
where id = #{id}
</update>
<select id="listPagePFRepoCash" resultMap="repoCashResultMap"
parameterType="com.mmc.payment.model.qo.RepoCashQO">
select c.id,c.repo_account_id,c.ware_title,c.pay_no,
c.order_no,c.refund_no,c.create_user,c.pay_method,
c.amt_paid,c.cash_amt,c.remark,c.voucher
from repo_cash c
<where>
and c.repo_account_id = #{repoAccountId}
<if test=" keyword!=null and keyword!='' ">
and (
c.ware_title like CONCAT('%',#{keyword},'%')
or c.pay_no like CONCAT('%',#{keyword},'%')
or c.order_no like CONCAT('%',#{keyword},'%')
or c.refund_no like CONCAT('%',#{keyword},'%')
)
</if>
<if test=" startTime != null and startTime != '' ">
and c.pay_time &gt;= STR_TO_DATE(#{startTime},'%Y-%m-%d
%H:%i:%s')
</if>
<if test=" endTime != null and endTime != '' ">
and c.pay_time &lt;= STR_TO_DATE(#{endTime},'%Y-%m-%d
%H:%i:%s')
</if>
<if test=" payMethod != null ">
and c.pay_method = #{payMethod}
</if>
</where>
order by c.pay_time desc
limit #{pageNo},#{pageSize}
</select>
<select id="countPagePFRepoCash" resultType="int"
parameterType="com.mmc.payment.model.qo.RepoCashQO">
select count(*)
from repo_cash c
<where>
and c.repo_account_id = #{repoAccountId}
<if test=" keyword!=null and keyword!='' ">
and (
c.ware_title like CONCAT('%',#{keyword},'%')
or c.pay_no like CONCAT('%',#{keyword},'%')
or c.order_no like CONCAT('%',#{keyword},'%')
or c.refund_no like CONCAT('%',#{keyword},'%')
)
</if>
<if test=" startTime != null and startTime != '' ">
and c.pay_time &gt;= STR_TO_DATE(#{startTime},'%Y-%m-%d
%H:%i:%s')
</if>
<if test=" endTime != null and endTime != '' ">
and c.pay_time &lt;= STR_TO_DATE(#{endTime},'%Y-%m-%d
%H:%i:%s')
</if>
<if test=" payMethod != null ">
and c.pay_method = #{payMethod}
</if>
</where>
</select>
<select id="getRepoWalletInfo" resultMap="repoWalletResultMap">
select w.id,
w.repo_account_id,
w.cash_amt,
w.cash_freeze,
w.cash_paid,
w.rcd_rebate_amt,
w.rebate_wdl,
w.rebate_freeze,
w.create_time,
w.update_time
from repo_wallet w
where w.repo_account_id = #{repoAccountId}
</select>
<update id="updateRepoWalletAmt">
update repo_wallet
set cash_amt = cash_amt + #{chageAmt}
where repo_account_id = #{repoAccountId}
</update>
<select id="RemainingBalance" resultType="java.math.BigDecimal">
select cash_amt
from repo_wallet
where repo_account_id = #{repoAccountId}
</select>
<update id="updateWalletAmt">
update repo_wallet
set cash_amt = cash_amt + #{addAmt},
cash_paid = cash_paid + #{addPaid}
where repo_account_id = #{repoAccountId}
</update>
<insert id="orderPayment" useGeneratedKeys="true"
keyProperty="id" parameterType="com.mmc.payment.entity.RepoCashDO">
insert into repo_cash
(repo_account_id, uid, account_name, order_info_id, order_no, sku_info_id, sku_title,
ware_info_id, ware_no, ware_title, pay_no, pay_method, amt_paid, cash_amt, pay_time, remark,
voucher, refund_no, update_time, update_user, create_time, create_user)
values (#{repoAccountId}, #{uid}, #{accountName}, #{orderInfoId}, #{orderNo}, #{skuInfoId}, #{skuTitle},
#{wareInfoId}, #{wareNo}, #{wareTitle}, #{payNo}, #{payMethod}, #{amtPaid}, #{cashAmt}, #{payTime},
#{remark},
#{voucher}, #{refundNo}, #{updateTime}, #{updateUser}, #{createTime}, #{createUser})
</insert>
</mapper>
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论