Commit 39991a52 by ning

贵金属防伪系统

parent ef5efef9
package com.junmp.gold.api.bean.dto;
import lombok.Data;
import java.io.Serializable;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/3 13:21
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
public class ProductBatchDto implements Serializable {
/**
* 批次编号
*/
private Long batchId;
/**
* 批次号
*/
private String batchNo;
/**
* 产品编号
*/
private Long productId;
/**
* 产品名称
*/
private String productName;
/**
* 号型编号
*/
private Long specId;
/**
* 号型
*/
private String spec;
/**
* 重量
*/
private String weight;
/**
* 材质
*/
private String material;
/**
* 计划生产数
*/
private Integer total;
/**
* 是否复检完成
*/
private Boolean hasFinish;
/**
* 是否初始化完成
*/
private Boolean hasInit ;
/**
* 已生产数量
*/
private Integer doneNum;
}
package com.junmp.gold.api.bean.dto;
import lombok.Data;
import java.io.Serializable;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/3 13:21
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
public class ProductProcessDto implements Serializable {
/**
* 批次编号
*/
private Long batchId;
/**
* 批次号
*/
private String batchNo;
/**
* 产品编号
*/
private Long productId;
/**
* 产品名称
*/
private String productName;
/**
* 号型编号
*/
private Long specId;
/**
* 号型
*/
private String spec;
/**
* 重量
*/
private String weight;
/**
* 材质
*/
private String material;
/**
* 计划生产数
*/
private Integer total;
/**
* 是否复检完成
*/
private Boolean hasFinish;
/**
* 是否初始化完成
*/
private Boolean hasInit;
/**
* 已自检数量
*/
private Integer checkedNum;
/**
* 待自检数量
*/
private Integer waitingNum;
}
package com.junmp.gold.api.bean.dto;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/5 15:32
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
public class ProductTagDto implements Serializable {
private Long tagId ;
private String productCode ;
private String password;
private String ciphertext ;
private String productName ;
private Date produceTime ;
private String spec ;
private String material ;
private String weight ;
private String companyName ;
}
package com.junmp.gold.api.bean.dto;
import lombok.Data;
import java.io.Serializable;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/5 15:56
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
public class SimpleTagDto implements Serializable {
private Long tagId ;
private String productCode ;
}
package com.junmp.gold.api.bean.req;
import com.junmp.v2.common.bean.request.BaseRequest;
import com.junmp.v2.validator.api.validators.unique.TableUniqueValue;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 10:56
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class CompanyReq extends BaseRequest {
@NotNull(message = "企业编号不能为空", groups = {edit.class, delete.class, detail.class})
private Long bizId;
@NotBlank(message = "企业编码不能为空", groups = {edit.class})
@TableUniqueValue(
message = "编码重复",
groups = {edit.class},
tableName = "biz_company",
columnName = "biz_code",
idFieldName = "biz_id")
private String bizCode;
/**
* 单位类型
*/
private String bizType;
/**
* 名称
*/
private String name;
/**
* 简称
*/
private String shortName;
/**
* 备注
*/
private String remark;
}
package com.junmp.gold.api.bean.req;
import com.junmp.v2.common.bean.request.BaseRequest;
import com.junmp.v2.validator.api.validators.unique.TableUniqueValue;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/2 10:11
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class ProductBatchReq extends BaseRequest {
/**
* 批次主键
*/
@NotNull(message = "批次主键不能为空", groups = {edit.class, delete.class, detail.class})
private Long batchId;
/**
* 批次编号
*/
@NotBlank(message = "批次号不能为空", groups = {edit.class})
@TableUniqueValue(
message = "批次号重复",
groups = {edit.class},
tableName = "biz_product_batch",
columnName = "batch_no",
idFieldName = "batch_id")
private String batchNo;
/**
* 产品编号
*/
@NotNull(message = "批次主键不能为空", groups = {edit.class, add.class})
private Long productId;
/**
* 关联号型
*/
private Long specId;
/**
* 生产总量
*/
@NotNull(message = "批次主键不能为空", groups = {edit.class, add.class})
private Integer total;
/**
* 序号前缀
*/
private String prefix;
}
package com.junmp.gold.api.bean.req;
import com.junmp.v2.common.bean.request.BaseRequest;
import com.junmp.v2.validator.api.validators.unique.TableUniqueValue;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 16:29
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class ProductReq extends BaseRequest {
@NotNull(message = "产品主键不能为空", groups = {edit.class, delete.class, detail.class})
private Long productId;
/**
* 产品代码
*/
@NotBlank(message = "产品编码不能为空", groups = {edit.class})
@TableUniqueValue(
message = "编码重复",
groups = {edit.class},
tableName = "biz_product",
columnName = "product_code",
idFieldName = "product_id")
private String productCode;
/**
* 产品当前序号
*/
private Integer sn;
/**
* 产品名称
*/
private String name;
/**
* 条码信息
*/
private String barcode;
/**
* 重量
*/
private String weight;
/**
* 规格尺寸
*/
private String spec;
/**
* 材质
*/
private String material;
/**
* 计量单位
*/
private String unit;
/**
* 图片地址
*/
private String imageUrl;
/**
* 生产厂家编号
*/
private Long mfBizId;
/**
* 生产厂家名称
*/
private String mfBizName;
}
package com.junmp.gold.api.bean.req;
import com.junmp.v2.common.bean.request.BaseRequest;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotNull;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 18:28
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class ProductSkuReq extends BaseRequest {
@NotNull(message = "号型主键不能为空", groups = {edit.class, delete.class, detail.class})
private Long specId;
private String skuCode ;
/**
* 号型
*/
private String spec;
/**
* 重量
*/
private String weight;
/**
* 材质
*/
private String material;
/**
* 关联产品
*/
private Long productId;
/**
* 预览属性1
*/
private String attr1;
/**
* 预览属性2
*/
private String attr2;
/**
* 预览属性3
*/
private String attr3;
}
package com.junmp.gold.api.bean.req;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.junmp.v2.common.bean.request.BaseRequest;
import com.junmp.v2.validator.api.validators.unique.TableUniqueValue;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotNull;
import java.util.Date;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/2 14:36
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class ProductTagReq extends BaseRequest {
/**
* 标签编号
*/
@NotNull(message = "标签编号不能为空", groups = {edit.class, delete.class, detail.class})
private Long tagId;
private String tagUid;
/**
* 成品码(批次+序号)
*/
private String productCode;
/**
* 关联生成批次编号
*/
@NotNull(message = "批次不能为空", groups = {add.class})
private Long batchId;
/**
* 关联生成产品主键
*/
@NotNull(message = "产品不能为空", groups = {add.class})
private Long productId;
/**
* 关联生成号型主键
*/
@NotNull(message = "号型不能为空", groups = {add.class})
private Long specId;
/**
* 产品序号
*/
private Integer serialId;
/**
* 版本编号
*/
private String versionNo;
/**
* 密码
*/
private String password;
/**
* 密文内容
*/
private String ciphertext;
}
package com.junmp.gold.api.bean.vo;
import lombok.Data;
import java.io.Serializable;
/**
* <pre>
*
* 描述:NFC NDef的文本内容
* 版本:1.0.0
* 日期:2022/8/3 18:36
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
public class NDefContentVo implements Serializable {
/**
* 产品编号
*/
private String productNo;
/**
* 名称
*/
private String name;
/**
* 号型
*/
private String spec;
/**
* 重量
*/
private String weight;
/**
* 生产厂家
*/
private String company;
/**
* 生产时间
*/
private String produceTime;
/**
* 密文内容
*/
private String ciphertext;
}
package com.junmp.gold.api.bean.vo;
import lombok.Data;
import java.io.Serializable;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/2 16:13
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
public class ProductSkuVo implements Serializable {
/**
* 号型编号
*/
private Long specId;
/**
* 号型代码
*/
private String skuCode;
/**
* 号型名称
*/
private String spec;
/**
* 重量
*/
private String weight ;
}
package com.junmp.gold.api.bean.vo;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/5 16:33
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Builder
@Data
public class TagInfoVo implements Serializable {
private Long tagId ;
private String content ;
private String productCode;
}
package com.junmp.gold.api.constant;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 13:03
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public interface GoldConstant {
/**
* 系统管理模块的名称
*/
String GOLD_MODULE_NAME = "junmp-gold-app";
/**
* 异常枚举的步进值
*/
int GOLD_EXCEPTION_STEP_CODE = 400;
/**
* 缓存前缀
*/
String GOLD_CACHE_PREFIX = "gold:";
String GOLD_JWT_KEY = "JWT";
}
package com.junmp.gold.api.exception;
import cn.hutool.core.util.StrUtil;
import com.junmp.gold.api.constant.GoldConstant;
import com.junmp.v2.common.exception.IExceptionEnum;
import com.junmp.v2.common.exception.base.ServiceException;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 13:02
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public class GoldAppException extends ServiceException {
public GoldAppException(IExceptionEnum exception, Object... params) {
super(GoldConstant.GOLD_MODULE_NAME, exception.getCode(), StrUtil.format(exception.getMessage(), params));
}
public GoldAppException(IExceptionEnum exception) {
super(GoldConstant.GOLD_MODULE_NAME, exception);
}
}
package com.junmp.gold.api.exception.enums;
import com.junmp.gold.api.constant.GoldConstant;
import com.junmp.v2.common.constant.CommonConstant;
import com.junmp.v2.common.exception.IExceptionEnum;
import lombok.Getter;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 13:08
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Getter
public enum CompanyExceptionEnum implements IExceptionEnum {
/**
* 应用不存在
*/
COMPANY_NOT_EXIST(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 12, "企业不存在"),;
/**
* 错误编码
*/
private final Integer code;
/**
* 提示用户信息
*/
private final String message;
CompanyExceptionEnum(Integer code, String message) {
this.code = code;
this.message = message;
}
}
package com.junmp.gold.api.exception.enums;
import com.junmp.gold.api.constant.GoldConstant;
import com.junmp.v2.common.constant.CommonConstant;
import com.junmp.v2.common.exception.IExceptionEnum;
import lombok.Getter;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 13:08
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Getter
public enum ProductExceptionEnum implements IExceptionEnum {
/**
* 产品信息不存在
*/
PRODUCT_NOT_EXIST(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 12, "产品信息不存在"),
/**
* 产品信息不存在
*/
PRODUCT_SKU_NOT_EXIST(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 13, "号型不存在"),
/**
* 批次信息不存在
*/
BATCH_NOT_EXIST(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 14, "批次不存在"),
/**
* 批次信息不存在
*/
BATCH_PROCESSED(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 15, "批次已生产"),
/**
* 批次生产已完成
*/
BATCH_PROCESSED_DONE(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 16, "批次生产已完成"),
/**
* 批次生产已完成
*/
MODIFY_NUM_ERROR(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 17, "批次生产已完成,数量不能小于原数量"),
/**
* 标签信息不存在
*/
TAG_INFO_NOT_EXISTS(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 19, "标签信息不存在"),
/**
* 标签信息初始化完成
*/
TAG_INFO_INIT_DONE(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 20, "检查标签信息是否绑定完成"),
/**
* 标签已绑定
*/
TAG_INFO_HAD_BINDING(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 21, "标签已绑定"),
/**
* 确认绑定是否已完成
*/
TAG_UID_BINDING_ERROR(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 22, "确认绑定是否已完成"),
/**
* 标签重复
*/
TAG_INFO_REPEAT_ERROR(CommonConstant.DEFAULT_USER_ERROR_CODE + GoldConstant.GOLD_EXCEPTION_STEP_CODE + 23, "标签重复"),
;
/**
* 错误编码
*/
private final Integer code;
/**
* 提示用户信息
*/
private final String message;
ProductExceptionEnum(Integer code, String message) {
this.code = code;
this.message = message;
}
}
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 13:08
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
package com.junmp.gold.api.exception.enums;
package com.junmp.gold.api.util;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import java.util.Date;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 13:36
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public class GenCodeUtil {
private static final String QY_PREFIX = "11";
private static final String PRODUCT_PREFIX = "99";
private static final String HX_PREFIX = "1";
/**
* 字符串前面补零操作
*
* @param str 字符串本体
* @param len 需要的字符串总长度
* @return
*/
public static String splicingZero(String str, int len) {
int strLen = str.length();
String strReturn = str;
for (int i = 0; i < len - strLen; i++) {
strReturn = "0" + strReturn;
}
return strReturn.toUpperCase();
}
/**
* 生成企业代码
*
* @param sn 当前序号(11)
*/
public static String genBizCode(Integer sn) {
StringBuilder sb = new StringBuilder();
sb.append(QY_PREFIX);
sb.append(splicingZero(String.valueOf(sn), 4));
return sb.toString();
}
/**
* 生成产品代码
*
* @param sn 当前序号(11)
*/
public static String genProductCode(Integer sn) {
StringBuilder sb = new StringBuilder();
sb.append(PRODUCT_PREFIX).append(splicingZero(String.valueOf(sn), 4));
return sb.toString();
}
/**
* 生成号型代码
*
* @param sn 当前序号(11)
*/
public static String genSpecCode(Integer sn) {
StringBuilder sb = new StringBuilder();
sb.append(HX_PREFIX).append(splicingZero(String.valueOf(sn), 3));
return sb.toString();
}
/**
* 生产批次号
*/
public static String genBatchNo(Integer sn) {
StringBuilder sb = new StringBuilder();
sb.append(DateUtil.format(new Date(), DatePattern.PURE_DATE_PATTERN))
.append(splicingZero(String.valueOf(sn), 4));
return sb.toString();
}
/**
* 生产SKU
*
* @param productCode
* @param hxCode
*/
public static String genSkuCode(String productCode, String hxCode) {
StringBuilder sb = new StringBuilder();
sb.append(productCode).append(hxCode);
return sb.toString();
}
}
package com.junmp.gold.cache;
import com.junmp.gold.api.constant.GoldConstant;
import com.junmp.v2.cache.AbstractRedisCache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 16:51
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Component
public class GoldRedisCache extends AbstractRedisCache<String> {
public GoldRedisCache(RedisTemplate<String, String> redisTemplate) {
super(redisTemplate);
}
@Override
public String getCommonKeyPrefix() {
return GoldConstant.GOLD_CACHE_PREFIX;
}
}
package com.junmp.gold.controller;
import cn.hutool.core.util.StrUtil;
import com.junmp.gold.api.bean.req.CompanyReq;
import com.junmp.gold.doc.CompanyDoc;
import com.junmp.gold.entity.Company;
import com.junmp.gold.service.CompanyService;
import com.junmp.v2.common.bean.request.ValidationApi;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.exception.enums.DefaultBizExceptionEnum;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 10:24
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@RestController
@Slf4j
@RequestMapping("/api")
public class CompanyController implements CompanyDoc {
@Resource
private CompanyService companyService;
@PostMapping(path = "/company", name = "新增企业")
@Override
public ApiRes<Boolean> addBiz(@RequestBody @Validated(CompanyReq.add.class) CompanyReq req) {
try {
companyService.addBiz(req);
return ApiRes.success();
} catch (ServiceException ex) {
log.error("企业新增异常>>" + ex.getMessage());
return ApiRes.failure(DefaultBizExceptionEnum.SYS_RUNTIME_ERROR);
}
}
@PutMapping(path = "/company", name = "编辑企业")
@Override
public ApiRes<Boolean> editBiz(@RequestBody @Validated(ValidationApi.edit.class) CompanyReq req) {
boolean flag = companyService.editBiz(req);
if (flag) {
return ApiRes.success();
} else {
return ApiRes.failure(StrUtil.format("单位编码:{},更新失败", req.getBizCode()));
}
}
@GetMapping(path = "/company", name = "企业列表")
@Override
public ApiRes<List<Company>> list(CompanyReq req) {
List<Company> list = companyService.findList(req);
return ApiRes.success(list);
}
@DeleteMapping(path = "/company", name = "删除企业")
@Override
public ApiRes<Boolean> delBiz(@RequestBody @Validated(ValidationApi.delete.class) CompanyReq req) {
boolean flag = companyService.del(req);
if (flag) {
return ApiRes.success();
} else {
return ApiRes.failure(StrUtil.format("单位编码:{},删除失败", req.getBizCode()));
}
}
@GetMapping(path = "/company/page", name = "分页企业信息")
@Override
public ApiRes<PageResult<Company>> page(CompanyReq req) {
return ApiRes.success(companyService.findPage(req));
}
}
package com.junmp.gold.controller;
import cn.hutool.core.util.StrUtil;
import com.junmp.gold.api.constant.GoldConstant;
import com.junmp.gold.cache.GoldRedisCache;
import com.junmp.gold.doc.LoginDoc;
import com.junmp.v2.auth.api.bean.auth.LoginReq;
import com.junmp.v2.auth.api.bean.auth.LoginRes;
import com.junmp.v2.auth.sign.AuthContainer;
import com.junmp.v2.common.bean.response.ApiRes;
import lombok.extern.slf4j.Slf4j;
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.annotation.Resource;
/**
* <pre>
*
* 描述:登录服务
* 版本:1.0.0
* 日期:2022/6/7 13:47
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Slf4j
@RestController
@RequestMapping("/api")
public class LoginController implements LoginDoc {
@Resource
private AuthContainer authContainer;
@Resource
private GoldRedisCache goldRedisCache ;
@PostMapping(name = "用户登录", path = "/auth/login")
public ApiRes<LoginRes> login(@RequestBody LoginReq req) {
LoginRes res = authContainer.login(req);
if (null != res) {
//配置扩展信息
String jwt = goldRedisCache.get(GoldConstant.GOLD_JWT_KEY);
if(StrUtil.isEmpty(jwt)){
goldRedisCache.put(GoldConstant.GOLD_JWT_KEY,res.getToken());
}
return ApiRes.success(res);
} else {
return ApiRes.failure("登录失败");
}
}
@PostMapping(name = "用户登出", path = "/auth/logout")
public ApiRes<Boolean> logout(){
authContainer.logout();
log.info("登出成功");
return ApiRes.success();
}
}
package com.junmp.gold.controller;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.junmp.gold.api.bean.dto.ProductBatchDto;
import com.junmp.gold.api.bean.dto.ProductProcessDto;
import com.junmp.gold.api.bean.req.ProductBatchReq;
import com.junmp.gold.api.exception.enums.ProductExceptionEnum;
import com.junmp.gold.api.util.GenCodeUtil;
import com.junmp.gold.doc.ProductBatchDoc;
import com.junmp.gold.entity.ProductBatch;
import com.junmp.gold.entity.ProductTag;
import com.junmp.gold.service.ProductBatchService;
import com.junmp.gold.service.ProductTagService;
import com.junmp.v2.common.bean.request.ValidationApi;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.exception.enums.DefaultBizExceptionEnum;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 17:59
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@RestController
@Slf4j
@RequestMapping("/api")
public class ProductBatchController implements ProductBatchDoc {
@Resource
private ProductBatchService productBatchService;
@Resource
private ProductTagService productTagService;
@PostMapping(path = "/batch/produce", name = "生产产品批次")
public ApiRes<Boolean> makeProduct(@RequestBody @Validated(ValidationApi.detail.class) ProductBatchReq req) {
if (ObjectUtil.isNotNull(req) && ObjectUtil.isNotNull(req.getBatchId())) {
ProductBatchDto dto = productBatchService.getBatchDetail(req.getBatchId());
List<ProductTag> list = batchTagInfo(dto);
if (null != list && list.size() > 0) {
productTagService.saveBatch(list);
//更新已完成
ProductBatch pb = new ProductBatch();
pb.setBatchId(req.getBatchId());
pb.setHasInit(true);
productBatchService.updateById(pb);
return ApiRes.success();
} else {
return ApiRes.failure("没有可生产数据");
}
} else {
return ApiRes.failure(DefaultBizExceptionEnum.VALID_PARAMS_ERROR);
}
}
@PostMapping(path = "/batch", name = "新增产品批次")
@Override
public ApiRes<Boolean> addProductBatch(@RequestBody @Validated(ValidationApi.add.class) ProductBatchReq req) {
boolean flag = productBatchService.addProductBatch(req);
if (flag) {
return ApiRes.success();
} else {
log.warn(StrUtil.format("请求的参数:{}", JSONUtil.toJsonStr(req)));
return ApiRes.failure(StrUtil.format("保存失败"));
}
}
@PutMapping(path = "/batch", name = "更新产品批次")
@Override
public ApiRes<Boolean> editProductBatch(@RequestBody @Validated(ValidationApi.edit.class) ProductBatchReq req) {
boolean flag = productBatchService.editProductBatch(req);
if (flag) {
return ApiRes.success();
} else {
log.warn(StrUtil.format("请求的参数:{}", JSONUtil.toJsonStr(req)));
return ApiRes.failure(StrUtil.format("更新失败"));
}
}
@DeleteMapping(path = "/batch", name = "删除产品批次")
@Override
public ApiRes<Boolean> delBatch(@RequestBody @Validated(ValidationApi.delete.class) ProductBatchReq req) {
try {
boolean flag = productBatchService.del(req);
if (flag) {
return ApiRes.success();
} else {
return ApiRes.failure("删除失败");
}
} catch (ServiceException ex) {
return ApiRes.failure(ex.getMessage());
}
}
@GetMapping(path = "/batch/page", name = "分页批次数据")
@Override
public ApiRes<PageResult<ProductBatchDto>> getPage(ProductBatchReq req) {
return ApiRes.success(productBatchService.findPage(req));
}
@GetMapping(path = "/batch/process/page", name = "分页批次数据")
@Override
public ApiRes<PageResult<ProductProcessDto>> getProcessPage(ProductBatchReq req) {
return ApiRes.success(productBatchService.findProcessPage(req));
}
/**
* 批次信息
*/
private List<ProductTag> batchTagInfo(ProductBatchDto batch) {
if (batch.getHasInit()) {
throw new ServiceException(ProductExceptionEnum.BATCH_PROCESSED_DONE);
} else {
List<ProductTag> list = new ArrayList<>();
Integer total = batch.getTotal();
Integer initVal = batch.getDoneNum() > 0 ? batch.getDoneNum() : 1;
for (; initVal <= total; initVal++) {
ProductTag tag = new ProductTag();
tag.setBatchId(batch.getBatchId());
tag.setProductId(batch.getProductId());
tag.setSpecId(batch.getSpecId());
tag.setProduceTime(new Date());
//成品码
StringBuilder sb = new StringBuilder();
String serialNo = GenCodeUtil.splicingZero(String.valueOf(initVal), 4);
sb.append(batch.getBatchNo())
.append(serialNo);
tag.setProductCode(sb.toString());
tag.setSerialId(initVal);
tag.setHasInit(false);
tag.setHasChecked(false);
list.add(tag);
}
return list;
}
}
}
package com.junmp.gold.controller;
import com.junmp.gold.api.bean.req.ProductReq;
import com.junmp.gold.doc.ProductDoc;
import com.junmp.gold.entity.Product;
import com.junmp.gold.service.ProductService;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 16:25
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@RestController
@Slf4j
@RequestMapping("/api")
public class ProductController implements ProductDoc {
@Resource
private ProductService productService;
@PostMapping(path = "/product", name = "新增产品")
@Override
public ApiRes<Boolean> addProduct(@RequestBody @Validated(ProductReq.add.class) ProductReq req) {
return ApiRes.success(productService.addProduct(req));
}
@PutMapping(path = "/product", name = "编辑产品")
@Override
public ApiRes<Boolean> editProduct(@RequestBody @Validated(ProductReq.edit.class) ProductReq req) {
return ApiRes.success(productService.editProduct(req));
}
@GetMapping(path = "/product", name = "产品列表")
@Override
public ApiRes<List<Product>> list(ProductReq req) {
return ApiRes.success(productService.findList(req));
}
@DeleteMapping(path = "/product", name = "删除产品")
@Override
public ApiRes<Boolean> delProduct(@RequestBody @Validated(ProductReq.delete.class)ProductReq req) {
return ApiRes.success(productService.del(req));
}
@GetMapping(path = "/product/page", name = "产品分页")
@Override
public ApiRes<PageResult<Product>> page(ProductReq req) {
return ApiRes.success(productService.findPage(req));
}
}
package com.junmp.gold.controller;
import cn.hutool.core.util.ObjectUtil;
import com.junmp.gold.api.bean.req.ProductSkuReq;
import com.junmp.gold.api.bean.vo.ProductSkuVo;
import com.junmp.gold.doc.ProductSkuDoc;
import com.junmp.gold.entity.ProductSku;
import com.junmp.gold.service.ProductSkuService;
import com.junmp.v2.common.bean.request.ValidationApi;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.exception.enums.DefaultBizExceptionEnum;
import com.junmp.v2.common.util.BeanPlusUtil;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 17:59
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@RestController
@Slf4j
@RequestMapping("/api")
public class ProductSkuController implements ProductSkuDoc {
@Resource
private ProductSkuService productSkuService;
@PostMapping(path = "/spec", name = "新增号型")
@Override
public ApiRes<Boolean> addProductSku(@RequestBody @Validated(ProductSkuReq.add.class) ProductSkuReq req) {
try {
productSkuService.addProductSku(req);
return ApiRes.success();
} catch (ServiceException ex) {
log.error("新增号型异常>>" + ex.getMessage());
return ApiRes.failure(DefaultBizExceptionEnum.SYS_RUNTIME_ERROR);
}
}
@PutMapping(path = "/spec", name = "编辑号型")
@Override
public ApiRes<Boolean> editProductSku(@RequestBody @Validated(ProductSkuReq.edit.class)ProductSkuReq req) {
return ApiRes.success(productSkuService.editProductSku(req));
}
@DeleteMapping(path = "/spec", name = "删除号型")
@Override
public ApiRes<Boolean> del(@RequestBody @Validated(ValidationApi.delete.class)ProductSkuReq req) {
return ApiRes.success(productSkuService.del(req));
}
@GetMapping(path = "/spec/page", name = "分页号型")
@Override
public ApiRes<PageResult<ProductSku>> page(ProductSkuReq req) {
return ApiRes.success(productSkuService.findPage(req));
}
@GetMapping(path = "/spec/getByProduct", name = "获取指定产品号型列表")
@Override
public ApiRes<List<ProductSkuVo>> listByProduct(ProductSkuReq req) {
if (ObjectUtil.isNotNull(req) && ObjectUtil.isNotNull(req.getProductId())) {
List<ProductSku> list = productSkuService.findList(req);
return ApiRes.success(BeanPlusUtil.toBeanList(list, ProductSkuVo.class));
} else {
return ApiRes.failure("产品编号不能为空");
}
}
}
package com.junmp.gold.controller;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.HexUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.junmp.gold.api.bean.dto.ProductTagDto;
import com.junmp.gold.api.bean.req.ProductTagReq;
import com.junmp.gold.api.bean.vo.TagInfoVo;
import com.junmp.gold.api.exception.enums.ProductExceptionEnum;
import com.junmp.gold.doc.ProductTagDoc;
import com.junmp.gold.entity.ProductTag;
import com.junmp.gold.service.ProductTagService;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.common.exception.enums.DefaultBizExceptionEnum;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.Date;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 17:59
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@RestController
@Slf4j
@RequestMapping("/api")
public class ProductTagController implements ProductTagDoc {
@Resource
private ProductTagService productTagService;
/**
* 前端参数包括:batchId 和 tagUid
*/
@PostMapping(path = "/tag/updateUid", name = "更新标签UID")
@Override
public ApiRes<TagInfoVo> updateUid(@RequestBody ProductTagReq req) {
ProductTag info = productTagService.checkTagUid(req);
info.setTagUid(req.getTagUid());
info.setHasInit(true);
boolean flag = productTagService.updateById(info);
if (flag) {
String hexStr = HexUtil.encodeHexStr(info.getProductCode());
return ApiRes.success(TagInfoVo.builder().tagId(info.getTagId()).content(hexStr).build());
} else {
return ApiRes.failure("UID数据更新失败");
}
}
/**
* 前端参数包括:tagId,password,ciphertext
*/
@PostMapping(path = "/tag/updateContent", name = "更新内容")
@Override
public ApiRes<TagInfoVo> updateContent(@RequestBody ProductTagReq req) {
if (ObjectUtil.isNotNull(req) && ObjectUtil.isNotNull(req.getTagId())) {
ProductTag info = productTagService.getById(req.getTagId());
if (null != info) {
info.setPassword(req.getPassword());
info.setCiphertext(req.getCiphertext());
boolean flag = productTagService.updateById(info);
if (flag) {
//查询视图获取数据
ProductTagDto dto = productTagService.getTagInfo(req.getTagId());
StringBuilder tmp = new StringBuilder();
Set<String> params = new LinkedHashSet<>();
if (StrUtil.isNotBlank(dto.getCompanyName())) {
tmp.append("厂家:{}\n");
params.add(dto.getCompanyName());
}
if (StrUtil.isNotBlank(dto.getProductName())) {
tmp.append("名称:{}\n");
params.add(dto.getProductName());
}
if (StrUtil.isNotBlank(dto.getSpec())) {
tmp.append("规格:{}\n");
params.add(dto.getSpec());
}
if (StrUtil.isNotBlank(dto.getMaterial())) {
tmp.append("材质:{}\n");
params.add(dto.getMaterial());
}
if (StrUtil.isNotBlank(dto.getWeight())) {
tmp.append("重量:{}\n");
params.add(dto.getWeight());
}
//厂家:{}\n日期:{}
tmp.append("编号:{}\n");
params.add(dto.getProductCode());
log.info(StrUtil.format("待写入的模板:{}", tmp.toString()));
//String abc = "名称:{}\n规格:{}\n重量:{}\n厂家:{}\n日期:{}\n编号:{}\n";
String content = StrUtil.format(tmp.toString(), params.toArray());
log.info(StrUtil.format("写入的内容:{}", content));
return ApiRes.success(TagInfoVo.builder()
.tagId(req.getTagId())
.productCode(dto.getCiphertext())
.content(content).build());
} else {
return ApiRes.failure("UID数据更新失败");
}
} else {
return ApiRes.failure(ProductExceptionEnum.TAG_INFO_NOT_EXISTS);
}
} else {
return ApiRes.failure(DefaultBizExceptionEnum.VALID_PARAMS_ERROR);
}
}
/**
* 前端参数:tagUid,productCode
*/
@PostMapping(path = "/tag/check", name = "复检接口")
public ApiRes<Boolean> checkTag(@RequestBody ProductTagReq req) {
if (ObjectUtil.isNotNull(req) &&
ObjectUtil.isNotNull(req.getTagUid()) &&
ObjectUtil.isNotNull(req.getProductCode())) {
String code = HexUtil.decodeHexStr(req.getProductCode());
req.setProductCode(code);
List<ProductTag> list = productTagService.findList(req);
if (CollectionUtil.isNotEmpty(list) && list.size() == 1) {
ProductTag tag = list.get(0);
log.info(StrUtil.format("复检结果为:{}", JSONUtil.toJsonStr(tag)));
if (tag.getHasChecked()) {
log.warn("该产品已完成自检,编号为:{}", req.getTagUid());
return ApiRes.success();
}
if (ObjectUtil.isNotNull(tag)) {
//更新为已经复检
tag.setHasChecked(true);
tag.setCheckTime(new Date());
productTagService.updateById(tag);
return ApiRes.success();
} else {
return ApiRes.failure(ProductExceptionEnum.TAG_INFO_NOT_EXISTS);
}
} else {
return ApiRes.failure(ProductExceptionEnum.TAG_INFO_REPEAT_ERROR);
}
} else {
return ApiRes.failure(DefaultBizExceptionEnum.VALID_PARAMS_ERROR);
}
}
@GetMapping(path = "/tag/page", name = "分页标签")
public ApiRes<PageResult<ProductTag>> getPage(ProductTagReq req) {
return ApiRes.success(productTagService.findPage(req));
}
}
package com.junmp.gold.doc;
import com.junmp.gold.api.bean.req.CompanyReq;
import com.junmp.gold.entity.Company;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.db.api.page.PageResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 10:47
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Api(value = "企业管理", tags = "企业管理接口")
public interface CompanyDoc {
/**
* 新增企业
*/
@ApiOperation(value = "新增企业", tags = "企业管理接口")
ApiRes<Boolean> addBiz(CompanyReq req);
/**
* 更新企业
*/
@ApiOperation(value = "更新企业", tags = "企业管理接口")
ApiRes<Boolean> editBiz(CompanyReq req);
/**
* 获取所有企业
*/
@ApiOperation(value = "获取所有企业", tags = "企业管理接口")
ApiRes<List<Company>> list(CompanyReq req);
/**
* 删除企业
*/
@ApiOperation(value = "删除企业",tags = "企业管理接口")
ApiRes<Boolean> delBiz(CompanyReq req);
/**
* 企业信息分页
*/
@ApiOperation(value = "分页企业信息", tags = "企业管理接口")
ApiRes<PageResult<Company>> page(CompanyReq req);
}
package com.junmp.gold.doc;
import com.junmp.v2.auth.api.bean.auth.LoginReq;
import com.junmp.v2.auth.api.bean.auth.LoginRes;
import com.junmp.v2.common.bean.response.ApiRes;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.RequestBody;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 17:05
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Api(value = "登录登出管理", tags = "登录管理接口")
public interface LoginDoc {
/**
* 登录
*
* @param req
*/
@ApiOperation(value = "用户登录", tags = "登录管理接口")
ApiRes<LoginRes> login(LoginReq req);
/**
* 登出
*/
@ApiOperation(value = "用户退出", tags = "登录管理接口")
ApiRes<Boolean> logout();
}
package com.junmp.gold.doc;
import com.junmp.gold.api.bean.dto.ProductBatchDto;
import com.junmp.gold.api.bean.dto.ProductProcessDto;
import com.junmp.gold.api.bean.req.ProductBatchReq;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.db.api.page.PageResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 18:12
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Api(value = "生产管理", tags = "生产管理接口")
public interface ProductBatchDoc {
/**
* 生产标签
*
* @param req
*/
@ApiOperation(value = "生产初始化", tags = "生产管理接口")
ApiRes<Boolean> makeProduct(ProductBatchReq req);
/**
* 新增批次信息
*/
@ApiOperation(value = "新增批次信息", tags = "生产管理接口")
ApiRes<Boolean> addProductBatch(ProductBatchReq req);
/**
* 更新批次信息
*/
@ApiOperation(value = "更新批次信息", tags = "生产管理接口")
ApiRes<Boolean> editProductBatch(ProductBatchReq req);
/**
* 删除批次信息
*/
@ApiOperation(value = "删除批次信息", tags = "生产管理接口")
ApiRes<Boolean> delBatch(ProductBatchReq req);
/**
* 分页批次信息
*/
@ApiOperation(value = "分页批次信息", tags = "生产管理接口")
ApiRes<PageResult<ProductBatchDto>> getPage(ProductBatchReq req);
/**
* 分页批次信息
*/
@ApiOperation(value = "分页批次进度信息", tags = "生产管理接口")
ApiRes<PageResult<ProductProcessDto>> getProcessPage(ProductBatchReq req);
}
package com.junmp.gold.doc;
import com.junmp.gold.api.bean.req.CompanyReq;
import com.junmp.gold.api.bean.req.ProductReq;
import com.junmp.gold.entity.Company;
import com.junmp.gold.entity.Product;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.db.api.page.PageResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 16:25
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Api(value = "产品管理", tags = "产品管理接口")
public interface ProductDoc {
/**
* 新增产品
*/
@ApiOperation(value = "新增产品", tags = "产品管理接口")
ApiRes<Boolean> addProduct(ProductReq req);
/**
* 更新产品
*/
@ApiOperation(value = "更新产品", tags = "产品管理接口")
ApiRes<Boolean> editProduct(ProductReq req);
/**
* 获取所有产品
*/
@ApiOperation(value = "获取所有产品", tags = "产品管理接口")
ApiRes<List<Product>> list(ProductReq req);
/**
* 删除产品
*/
@ApiOperation(value = "删除产品",tags = "产品管理接口")
ApiRes<Boolean> delProduct(ProductReq req);
/**
* 分页产品信息
*/
@ApiOperation(value = "分页产品信息", tags = "产品管理接口")
ApiRes<PageResult<Product>> page(ProductReq req);
}
package com.junmp.gold.doc;
import com.junmp.gold.api.bean.req.ProductSkuReq;
import com.junmp.gold.api.bean.vo.ProductSkuVo;
import com.junmp.gold.entity.ProductSku;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.db.api.page.PageResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 18:00
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Api(value = "号型管理", tags = "产品号型接口")
public interface ProductSkuDoc {
/**
* 新增产品号型
*
* @param req
*/
@ApiOperation(value = "新增产品号型", tags = "产品号型接口")
ApiRes<Boolean> addProductSku(ProductSkuReq req);
/**
* 新增产品号型
*
* @param req
*/
@ApiOperation(value = "编辑号型", tags = "产品号型接口")
ApiRes<Boolean> editProductSku(ProductSkuReq req);
/**
* 新增产品号型
*
* @param req
*/
@ApiOperation(value = "删除号型", tags = "产品号型接口")
ApiRes<Boolean> del(ProductSkuReq req);
/**
* 新增产品号型
*
* @param req
*/
@ApiOperation(value = "分页产品信息", tags = "产品号型接口")
ApiRes<PageResult<ProductSku>> page(ProductSkuReq req);
/**
* 获取指定产品号型列表
*/
@ApiOperation(value = "获取指定产品号型列表", tags = "产品号型接口")
ApiRes<List<ProductSkuVo>> listByProduct(ProductSkuReq req);
}
package com.junmp.gold.doc;
import com.junmp.gold.api.bean.req.ProductTagReq;
import com.junmp.gold.api.bean.vo.TagInfoVo;
import com.junmp.gold.entity.ProductTag;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.db.api.page.PageResult;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.RequestBody;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 18:10
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Api(value = "生产管理", tags = "生产管理接口")
public interface ProductTagDoc {
@ApiOperation(value = "更新产品UID", tags = "生产管理接口")
ApiRes<TagInfoVo> updateUid(ProductTagReq req);
@ApiOperation(value = "更新产品内容", tags = "生产管理接口")
ApiRes<TagInfoVo> updateContent(ProductTagReq req);
@ApiOperation(value = "产品复检", tags = "生产管理接口")
ApiRes<Boolean> checkTag(ProductTagReq req);
@ApiOperation(value = "分页接口", tags = "生产管理接口")
ApiRes<PageResult<ProductTag>> getPage(ProductTagReq req);
}
package com.junmp.gold.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* <pre>
*
* 描述:业务单位信息
* 版本:1.0.0
* 日期:2022/7/29 16:42
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@TableName("biz_company")
public class Company implements Serializable {
/**
* 企业编号
*/
@TableId(value = "biz_id", type = IdType.AUTO)
private Long bizId;
/**
* 当前序号
*/
private Integer sn;
/**
* 企业编码
*/
@TableField("biz_code")
private String bizCode;
/**
* 企业类型
*/
@TableField("biz_type")
private String bizType;
/**
* 简称
*/
@TableField("short_name")
private String shortName;
/**
* 名称
*/
private String name;
private String remark;
@TableField(fill = FieldFill.INSERT, value = "create_time")
private Date createTime;
@TableField(fill = FieldFill.UPDATE, value = "update_time")
private Date updateTime;
}
package com.junmp.gold.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/29 16:54
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@TableName("biz_product")
public class Product implements Serializable {
@TableId(value = "product_id", type = IdType.AUTO)
private Long productId;
/**
* 产品代码
*/
@TableField("product_code")
private String productCode;
/**
* 产品当前序号
*/
private Integer sn;
/**
* 产品名称
*/
private String name;
/**
* 条码信息
*/
private String barcode;
/**
* 计量单位
*/
private String unit;
/**
* 重量
*/
private String weight;
/**
* 规格尺寸
*/
private String spec;
/**
* 材质
*/
private String material;
/**
* 图片地址
*/
@TableField("image_url")
private String imageUrl;
/**
* 生产厂家编号
*/
@TableField("mf_biz_id")
private Long mfBizId;
/**
* 生产厂家名称
*/
@TableField(value = "mf_biz_name")
private String mfBizName;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.UPDATE)
private Date updateTime;
}
package com.junmp.gold.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* <pre>
*
* 描述:产品批次
* 版本:1.0.0
* 日期:2022/7/29 17:10
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@TableName("biz_product_batch")
public class ProductBatch implements Serializable {
/**
* 批次主键
*/
@TableId(value = "batch_id", type = IdType.AUTO)
private Long batchId;
/**
* 批次编号
*/
@TableField(value = "batch_no")
private String batchNo;
private Integer sn;
/**
* 产品编号
*/
@TableField(value = "product_id")
private Long productId;
/**
* 关联号型
*/
@TableField(value = "spec_id")
private Long specId;
/**
* 生产总量
*/
private Integer total;
/**
* 序号前缀
*/
private String prefix;
/**
* 复检是否完成
*/
@TableField(value = "has_finish")
private Boolean hasFinish;
/**
* 生产是否完成
*/
@TableField(value = "has_init")
private Boolean hasInit;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.UPDATE)
private Date updateTime;
}
package com.junmp.gold.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;
/**
* <pre>
*
* 描述:产品SKU
* 版本:1.0.0
* 日期:2022/7/29 16:19
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@TableName("biz_product_sku")
public class ProductSku implements Serializable {
@TableId(type = IdType.AUTO, value = "spec_id")
private Long specId;
/**
* 号型代码
*/
@TableField(value = "spec_code")
private String specCode;
/**
* SKU编码
*/
@TableField(value = "sku_code")
private String skuCode;
/**
* 序号
*/
private Integer sn;
/**
* 号型
*/
private String spec;
/**
* 重量
*/
private String weight;
/**
* 材质
*/
private String material;
/**
* 关联产品
*/
@TableField(value = "product_id")
private Long productId;
/**
* 预览属性1
*/
private String attr1;
/**
* 预览属性2
*/
private String attr2;
/**
* 预览属性3
*/
private String attr3;
}
package com.junmp.gold.entity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/29 16:16
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Data
@TableName("biz_product_tag")
public class ProductTag implements Serializable {
/**
* 标签编号
*/
@TableId(value = "tag_id", type = IdType.AUTO)
private Long tagId;
/**
* RFID uid
*/
@TableField(value = "tag_uid")
private String tagUid;
/**
* 成品码
*/
@TableField(value = "product_code")
private String productCode;
/**
* 关联生成批次编号
*/
@TableField(value = "batch_id")
private Long batchId;
/**
* 关联生成产品主键
*/
@TableField(value = "product_id")
private Long productId;
/**
* 关联生成号型主键
*/
@TableField(value = "spec_id")
private Long specId;
/**
* 产品序号
*/
@TableField(value = "serial_id")
private Integer serialId;
/**
* 版本编号
*/
@TableField(value = "version_no")
private String versionNo;
/**
* 密文内容
*/
private String ciphertext;
/**
* 生产日期
*/
@TableField(value = "produce_time")
private Date produceTime;
/**
* 复检时间
*/
@TableField(value = "check_time")
private Date checkTime ;
/**
* 密码
*/
private String password;
/**
* 是否初始化
*/
@TableField(value = "has_init")
private Boolean hasInit ;
/**
* 是否复检
*/
@TableField(value = "has_checked")
private Boolean hasChecked;
/**
* 创建时间
*/
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/**
* 更新时间
*/
@TableField(value = "update_time", fill = FieldFill.UPDATE)
private Date updateTime;
}
package com.junmp.gold.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.junmp.gold.entity.Company;
import org.apache.ibatis.annotations.Mapper;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:45
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Mapper
public interface CompanyMapper extends BaseMapper<Company> {
/**
* 获取当前最大序号
*/
Integer getMaxSn();
}
package com.junmp.gold.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.junmp.gold.api.bean.dto.ProductBatchDto;
import com.junmp.gold.api.bean.dto.ProductProcessDto;
import com.junmp.gold.api.bean.req.ProductBatchReq;
import com.junmp.gold.entity.ProductBatch;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:43
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Mapper
public interface ProductBatchMapper extends BaseMapper<ProductBatch> {
/**
* 获取当前最大序号
*/
Integer getMaxSn();
/**
* 指定批次的生成进度
*
* @param batchId 批次号
*/
ProductBatchDto getBatchProcess(@Param("batchId") Long batchId);
/**
* 分页
*
* @param page
* @param req
*/
Page<ProductBatchDto> getBatchPage(@Param("page") Page<ProductBatchDto> page, @Param("batch") ProductBatchReq req);
/**
* 分页
*
* @param page
* @param req
*/
Page<ProductProcessDto> getBatchProcessPage(@Param("page") Page<ProductProcessDto> page, @Param("batch") ProductBatchReq req);
}
package com.junmp.gold.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.junmp.gold.entity.Product;
import org.apache.ibatis.annotations.Mapper;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:44
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Mapper
public interface ProductMapper extends BaseMapper<Product> {
/**
* 获取当前最大序号
*/
Integer getMaxSn();
}
package com.junmp.gold.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.junmp.gold.entity.ProductSku;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/29 16:25
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Mapper
public interface ProductSkuMapper extends BaseMapper<ProductSku> {
/**
* 获取当前产品最大序号
*
* @param productId 产品编号
*/
Integer getMaxSn(@Param("productId") Long productId);
/**
* 删除产品对应的号型
*
* @param productId 产品编号
*/
boolean delByProductId(@Param("productId") Long productId);
}
package com.junmp.gold.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.junmp.gold.api.bean.dto.ProductTagDto;
import com.junmp.gold.api.bean.dto.SimpleTagDto;
import com.junmp.gold.entity.ProductTag;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:45
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Mapper
public interface ProductTagMapper extends BaseMapper<ProductTag> {
/**
* 从指定批次取一条未生成的标签数据
*
* @param batchId 批次号
*/
SimpleTagDto getInitTagInfo(@Param("batchId") Long batchId);
/**
* 获取TAG
*/
ProductTagDto getTagInfoByTagId(@Param("tagId") Long tagId);
}
package com.junmp.gold.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.junmp.gold.api.bean.req.CompanyReq;
import com.junmp.gold.entity.Company;
import com.junmp.v2.db.api.page.PageResult;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 09:35
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public interface CompanyService extends IService<Company> {
/**
* 新增
*
* @param req
*/
boolean addBiz(CompanyReq req);
/**
* 编辑
*
* @param req
*/
boolean editBiz(CompanyReq req);
/**
* 删除
*
* @param req
*/
boolean del(CompanyReq req);
/**
* 列表信息
*
* @param req
*/
List<Company> findList(CompanyReq req);
/**
* 分页信息
*
* @param req
*/
PageResult<Company> findPage(CompanyReq req);
}
package com.junmp.gold.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.junmp.gold.api.bean.dto.ProductBatchDto;
import com.junmp.gold.api.bean.dto.ProductProcessDto;
import com.junmp.gold.api.bean.req.ProductBatchReq;
import com.junmp.gold.entity.ProductBatch;
import com.junmp.v2.db.api.page.PageResult;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:47
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public interface ProductBatchService extends IService<ProductBatch> {
/**
* 新增
*
* @param req
*/
boolean addProductBatch(ProductBatchReq req);
/**
* 编辑
*
* @param req
*/
boolean editProductBatch(ProductBatchReq req);
/**
* 删除
*
* @param req
*/
boolean del(ProductBatchReq req);
/**
* 列表信息
*
* @param req
*/
List<ProductBatch> findList(ProductBatchReq req);
/**
* 分页信息
*
* @param req
*/
PageResult<ProductBatchDto> findPage(ProductBatchReq req);
/**
* 分页信息
*
* @param req
*/
PageResult<ProductProcessDto> findProcessPage(ProductBatchReq req);
/**
* 获取批次详细信息
*
* @param batchId
*/
ProductBatchDto getBatchDetail(Long batchId);
}
package com.junmp.gold.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.junmp.gold.api.bean.req.CompanyReq;
import com.junmp.gold.api.bean.req.ProductReq;
import com.junmp.gold.entity.Company;
import com.junmp.gold.entity.Product;
import com.junmp.v2.db.api.page.PageResult;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:46
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public interface ProductService extends IService<Product> {
/**
* 新增
*
* @param req
*/
boolean addProduct(ProductReq req);
/**
* 编辑
*
* @param req
*/
boolean editProduct(ProductReq req);
/**
* 删除
*
* @param req
*/
boolean del(ProductReq req);
/**
* 列表信息
*
* @param req
*/
List<Product> findList(ProductReq req);
/**
* 分页信息
*
* @param req
*/
PageResult<Product> findPage(ProductReq req);
}
package com.junmp.gold.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.junmp.gold.api.bean.req.ProductSkuReq;
import com.junmp.gold.entity.ProductSku;
import com.junmp.v2.db.api.page.PageResult;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/29 16:25
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public interface ProductSkuService extends IService<ProductSku> {
/**
* 新增
*
* @param req
*/
boolean addProductSku(ProductSkuReq req);
/**
* 编辑
*
* @param req
*/
boolean editProductSku(ProductSkuReq req);
/**
* 删除
*
* @param req
*/
boolean del(ProductSkuReq req);
/**
* 删除产品关联的号型
*
* @param productId
*/
boolean delByProductId(Long productId);
/**
* 列表信息
*
* @param req
*/
List<ProductSku> findList(ProductSkuReq req);
/**
* 分页信息
*
* @param req
*/
PageResult<ProductSku> findPage(ProductSkuReq req);
}
package com.junmp.gold.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.junmp.gold.api.bean.dto.ProductTagDto;
import com.junmp.gold.api.bean.req.ProductTagReq;
import com.junmp.gold.entity.ProductTag;
import com.junmp.v2.db.api.page.PageResult;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 09:36
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public interface ProductTagService extends IService<ProductTag> {
/**
* 新增
*
* @param req
*/
boolean addTagInfo(ProductTagReq req);
/**
* 编辑
*
* @param req
*/
boolean editTagInfo(ProductTagReq req);
/**
* 删除
*
* @param req
*/
boolean del(ProductTagReq req);
/**
* 去一条未生产的标签数据
*/
ProductTag checkTagUid(ProductTagReq req);
/**
*
*/
ProductTag findByUid(String tagUid);
/**
* 获取标签信息
*/
ProductTagDto getTagInfo(Long tagId);
/**
* 列表信息
*
* @param req
*/
List<ProductTag> findList(ProductTagReq req);
/**
* 分页信息
*
* @param req
*/
PageResult<ProductTag> findPage(ProductTagReq req);
}
package com.junmp.gold.service.impl;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.junmp.gold.api.bean.req.CompanyReq;
import com.junmp.gold.api.exception.enums.CompanyExceptionEnum;
import com.junmp.gold.api.util.GenCodeUtil;
import com.junmp.gold.entity.Company;
import com.junmp.gold.mapper.CompanyMapper;
import com.junmp.gold.service.CompanyService;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.util.BeanPlusUtil;
import com.junmp.v2.db.api.factory.PageFactory;
import com.junmp.v2.db.api.factory.PageResultFactory;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 09:35
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Slf4j
@Service
public class CompanyServiceImpl extends ServiceImpl<CompanyMapper, Company> implements CompanyService {
@Override
public boolean addBiz(CompanyReq req) {
Company company = new Company();
BeanPlusUtil.copyProperties(req, company);
Integer maxSn = baseMapper.getMaxSn();
//1-获取当前序号
Integer sn = maxSn + 1;
company.setSn(sn);
//2-获取当前编码
String bizCode = GenCodeUtil.genBizCode(sn);
company.setBizCode(bizCode);
return this.save(company);
}
@Override
public boolean editBiz(CompanyReq req) {
Company company = queryCompany(req);
BeanPlusUtil.copyProperties(req, company);
return this.updateById(company);
}
@Override
public boolean del(CompanyReq req) {
Company entity = queryCompany(req);
if (ObjectUtil.isNull(entity)) {
log.warn(StrUtil.format("企业信息不存在,企业编号为:{}", req.getBizId()));
return false;
} else {
return this.removeById(entity.getBizId());
}
}
@Override
public List<Company> findList(CompanyReq req) {
LambdaQueryWrapper<Company> wrapper = createWrapper(req);
return this.list(wrapper);
}
@Override
public PageResult<Company> findPage(CompanyReq req) {
LambdaQueryWrapper<Company> wrapper = createWrapper(req);
Page<Company> page = this.page(PageFactory.getDefaultPage(), wrapper);
return PageResultFactory.createPageResult(page);
}
private Company queryCompany(CompanyReq req) {
Company app = this.getById(req.getBizId());
if (ObjectUtil.isNull(app)) {
throw new ServiceException(CompanyExceptionEnum.COMPANY_NOT_EXIST);
}
return app;
}
private LambdaQueryWrapper<Company> createWrapper(CompanyReq req) {
LambdaQueryWrapper<Company> wrapper = new LambdaQueryWrapper<>();
if (ObjectUtil.isEmpty(req)) {
return wrapper;
}
//根据业务编码查询
wrapper.like(ObjectUtil.isNotEmpty(req.getBizCode()), Company::getBizCode, req.getBizCode());
//根据企业名称模糊查询
wrapper.like(ObjectUtil.isNotEmpty(req.getName()), Company::getName, req.getName());
wrapper.orderByDesc(Company::getCreateTime);
return wrapper;
}
}
package com.junmp.gold.service.impl;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.junmp.gold.api.bean.dto.ProductBatchDto;
import com.junmp.gold.api.bean.dto.ProductProcessDto;
import com.junmp.gold.api.bean.req.ProductBatchReq;
import com.junmp.gold.api.exception.enums.ProductExceptionEnum;
import com.junmp.gold.api.util.GenCodeUtil;
import com.junmp.gold.entity.ProductBatch;
import com.junmp.gold.mapper.ProductBatchMapper;
import com.junmp.gold.service.ProductBatchService;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.exception.enums.DefaultBizExceptionEnum;
import com.junmp.v2.common.util.BeanPlusUtil;
import com.junmp.v2.db.api.factory.PageFactory;
import com.junmp.v2.db.api.factory.PageResultFactory;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:47
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Service
@Slf4j
public class ProductBatchServiceImpl extends ServiceImpl<ProductBatchMapper, ProductBatch> implements ProductBatchService {
@Override
public boolean addProductBatch(ProductBatchReq req) {
ProductBatch batch = new ProductBatch();
BeanPlusUtil.copyProperties(req, batch);
batch.setHasFinish(false);
batch.setHasInit(false);
Integer maxSn = baseMapper.getMaxSn();
Integer sn = maxSn + 1;
batch.setSn(sn);
String batchNo = GenCodeUtil.genBatchNo(sn);
batch.setBatchNo(batchNo);
return this.save(batch);
}
@Override
public boolean editProductBatch(ProductBatchReq req) {
ProductBatch batch = queryBatch(req);
//如果修改了生产数量大于开始的数量
if(batch.getHasInit() && (req.getTotal() < batch.getTotal())){
throw new ServiceException(ProductExceptionEnum.MODIFY_NUM_ERROR);
}
if (req.getTotal() > batch.getTotal()) {
batch.setHasInit(false);
}
BeanPlusUtil.copyProperties(req, batch);
return this.updateById(batch);
}
@Override
public boolean del(ProductBatchReq req) {
if (null != req && ObjectUtil.isNotNull(req.getBatchId())) {
ProductBatchDto batch = baseMapper.getBatchProcess(req.getBatchId());
if (ObjectUtil.isNull(batch)) {
//批次不存在
throw new ServiceException(ProductExceptionEnum.BATCH_NOT_EXIST);
} else {
if (!batch.getHasFinish() && (batch.getDoneNum() < 1)) {
return this.removeById(req.getBatchId());
} else {
throw new ServiceException(ProductExceptionEnum.BATCH_PROCESSED);
//生产中不能删除
}
}
} else {
//参数错误
throw new ServiceException(DefaultBizExceptionEnum.VALID_PARAMS_ERROR);
}
}
@Override
public List<ProductBatch> findList(ProductBatchReq req) {
return this.list(createWrapper(req));
}
@Override
public PageResult<ProductBatchDto> findPage(ProductBatchReq req) {
Page<ProductBatchDto> page = baseMapper.getBatchPage(PageFactory.getDefaultPage(req), req);
return PageResultFactory.createPageResult(page);
}
@Override
public PageResult<ProductProcessDto> findProcessPage(ProductBatchReq req) {
Page<ProductProcessDto> page = baseMapper.getBatchProcessPage(PageFactory.getDefaultPage(req), req);
return PageResultFactory.createPageResult(page);
}
@Override
public ProductBatchDto getBatchDetail(Long batchId) {
ProductBatchDto dto = baseMapper.getBatchProcess(batchId);
if (ObjectUtil.isNull(dto)) {
throw new ServiceException(ProductExceptionEnum.BATCH_NOT_EXIST);
}
return dto;
}
private ProductBatch queryBatch(ProductBatchReq req) {
ProductBatch app = this.getById(req.getBatchId());
if (ObjectUtil.isNull(app)) {
throw new ServiceException(ProductExceptionEnum.BATCH_NOT_EXIST);
}
return app;
}
private LambdaQueryWrapper<ProductBatch> createWrapper(ProductBatchReq req) {
LambdaQueryWrapper<ProductBatch> wrapper = new LambdaQueryWrapper<>();
if (ObjectUtil.isEmpty(req)) {
return wrapper;
}
//根据业务编码查询
wrapper.like(ObjectUtil.isNotEmpty(req.getBatchNo()), ProductBatch::getBatchNo, req.getBatchNo());
//根据企业名称模糊查询
wrapper.eq(ObjectUtil.isNotEmpty(req.getProductId()), ProductBatch::getProductId, req.getProductId());
wrapper.eq(ObjectUtil.isNotEmpty(req.getSpecId()), ProductBatch::getSpecId, req.getSpecId());
wrapper.orderByDesc(ProductBatch::getCreateTime);
return wrapper;
}
}
package com.junmp.gold.service.impl;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.junmp.gold.api.bean.req.CompanyReq;
import com.junmp.gold.api.bean.req.ProductReq;
import com.junmp.gold.api.exception.enums.CompanyExceptionEnum;
import com.junmp.gold.api.exception.enums.ProductExceptionEnum;
import com.junmp.gold.api.util.GenCodeUtil;
import com.junmp.gold.entity.Company;
import com.junmp.gold.entity.Product;
import com.junmp.gold.mapper.ProductMapper;
import com.junmp.gold.service.ProductService;
import com.junmp.gold.service.ProductSkuService;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.util.BeanPlusUtil;
import com.junmp.v2.db.api.factory.PageFactory;
import com.junmp.v2.db.api.factory.PageResultFactory;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/30 13:46
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Service
@Slf4j
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
@Resource
private ProductSkuService productSkuService;
@Override
public boolean addProduct(ProductReq req) {
Product product = new Product();
BeanPlusUtil.copyProperties(req, product);
Integer maxSn = baseMapper.getMaxSn();
//1-获取当前序号
Integer sn = maxSn + 1;
product.setSn(sn);
//2-获取当前编码
String code = GenCodeUtil.genProductCode(sn);
product.setProductCode(code);
return this.save(product);
}
@Override
public boolean editProduct(ProductReq req) {
Product product = this.queryProduct(req);
BeanPlusUtil.copyProperties(req, product);
return this.updateById(product);
}
@Override
@Transactional
public boolean del(ProductReq req) {
Product product = queryProduct(req);
this.removeById(req.getProductId());
productSkuService.delByProductId(product.getProductId());
return true;
}
@Override
public List<Product> findList(ProductReq req) {
LambdaQueryWrapper<Product> wrapper = createWrapper(req);
return this.list(wrapper);
}
@Override
public PageResult<Product> findPage(ProductReq req) {
LambdaQueryWrapper<Product> wrapper = createWrapper(req);
Page<Product> page = this.page(PageFactory.getDefaultPage(), wrapper);
return PageResultFactory.createPageResult(page);
}
private Product queryProduct(ProductReq req) {
Product app = this.getById(req.getProductId());
if (ObjectUtil.isNull(app)) {
throw new ServiceException(ProductExceptionEnum.PRODUCT_NOT_EXIST);
}
return app;
}
private LambdaQueryWrapper<Product> createWrapper(ProductReq req) {
LambdaQueryWrapper<Product> wrapper = new LambdaQueryWrapper<>();
if (ObjectUtil.isEmpty(req)) {
return wrapper;
}
//根据业务编码查询
wrapper.like(ObjectUtil.isNotEmpty(req.getProductCode()), Product::getProductCode, req.getProductCode());
//根据企业名称模糊查询
wrapper.like(ObjectUtil.isNotEmpty(req.getName()), Product::getName, req.getName());
wrapper.orderByDesc(Product::getCreateTime);
return wrapper;
}
}
package com.junmp.gold.service.impl;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.junmp.gold.api.bean.req.ProductSkuReq;
import com.junmp.gold.api.exception.GoldAppException;
import com.junmp.gold.api.exception.enums.ProductExceptionEnum;
import com.junmp.gold.api.util.GenCodeUtil;
import com.junmp.gold.entity.Product;
import com.junmp.gold.entity.ProductSku;
import com.junmp.gold.mapper.ProductSkuMapper;
import com.junmp.gold.service.ProductService;
import com.junmp.gold.service.ProductSkuService;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.util.BeanPlusUtil;
import com.junmp.v2.db.api.factory.PageFactory;
import com.junmp.v2.db.api.factory.PageResultFactory;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/29 16:26
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Slf4j
@Service
public class ProductSkuServiceImpl extends ServiceImpl<ProductSkuMapper, ProductSku> implements ProductSkuService {
@Resource
private ProductService productService;
@Override
public boolean addProductSku(ProductSkuReq req) {
ProductSku entity = new ProductSku();
BeanPlusUtil.copyProperties(req, entity);
Integer maxSn = baseMapper.getMaxSn(req.getProductId());
//1-获取当前序号
Integer sn = maxSn + 1;
entity.setSn(sn);
//2- 设置号型编号
String hxCode = GenCodeUtil.genSpecCode(sn);
entity.setSpecCode(hxCode);
//3-设置SKU代码
Product product = productService.getById(req.getProductId());
if (ObjectUtil.isNotNull(product)) {
entity.setSkuCode(GenCodeUtil.genSkuCode(product.getProductCode(), hxCode));
return this.save(entity);
} else {
log.warn(StrUtil.format("该产品不存在,编号为:{}", req.getProductId()));
throw new GoldAppException(ProductExceptionEnum.PRODUCT_NOT_EXIST);
}
}
@Override
public boolean editProductSku(ProductSkuReq req) {
ProductSku entity = queryProductSku(req);
BeanPlusUtil.copyProperties(req, entity);
return this.updateById(entity);
}
@Override
public boolean del(ProductSkuReq req) {
ProductSku sku = queryProductSku(req);
return removeById(sku.getSpecId());
}
@Override
public boolean delByProductId(Long productId) {
return baseMapper.delByProductId(productId);
}
@Override
public List<ProductSku> findList(ProductSkuReq req) {
LambdaQueryWrapper<ProductSku> wp = createWrapper(req);
return this.list(wp);
}
@Override
public PageResult<ProductSku> findPage(ProductSkuReq req) {
LambdaQueryWrapper<ProductSku> wrapper = createWrapper(req);
Page<ProductSku> page = this.page(PageFactory.getDefaultPage(), wrapper);
return PageResultFactory.createPageResult(page);
}
private ProductSku queryProductSku(ProductSkuReq req) {
ProductSku app = this.getById(req.getSpecId());
if (ObjectUtil.isNull(app)) {
throw new ServiceException(ProductExceptionEnum.PRODUCT_SKU_NOT_EXIST);
}
return app;
}
private LambdaQueryWrapper<ProductSku> createWrapper(ProductSkuReq req) {
LambdaQueryWrapper<ProductSku> wrapper = new LambdaQueryWrapper<>();
if (ObjectUtil.isEmpty(req)) {
return wrapper;
}
//根据业务编码查询
wrapper.like(ObjectUtil.isNotEmpty(req.getSkuCode()), ProductSku::getSkuCode, req.getSkuCode());
//根据企业名称模糊查询
wrapper.eq(ObjectUtil.isNotEmpty(req.getProductId()), ProductSku::getProductId, req.getProductId());
wrapper.orderByDesc(ProductSku::getSn);
return wrapper;
}
}
package com.junmp.gold.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.junmp.gold.api.bean.dto.ProductTagDto;
import com.junmp.gold.api.bean.dto.SimpleTagDto;
import com.junmp.gold.api.bean.req.ProductTagReq;
import com.junmp.gold.api.exception.enums.ProductExceptionEnum;
import com.junmp.gold.entity.ProductTag;
import com.junmp.gold.mapper.ProductTagMapper;
import com.junmp.gold.service.ProductTagService;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.common.util.BeanPlusUtil;
import com.junmp.v2.db.api.factory.PageFactory;
import com.junmp.v2.db.api.factory.PageResultFactory;
import com.junmp.v2.db.api.page.PageResult;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/8/1 09:36
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Service
@Slf4j
public class ProductTagServiceImpl extends ServiceImpl<ProductTagMapper, ProductTag> implements ProductTagService {
@Override
public boolean addTagInfo(ProductTagReq req) {
ProductTag tag = new ProductTag();
BeanPlusUtil.copyProperties(req, tag);
tag.setProduceTime(new Date());
tag.setHasChecked(false);
return this.save(tag);
}
@Override
public boolean editTagInfo(ProductTagReq req) {
return false;
}
@Override
public boolean del(ProductTagReq req) {
return false;
}
@Override
public ProductTag checkTagUid(ProductTagReq req) {
//1-查找TagUid是否绑定
ProductTag tag = findByUid(req.getTagUid());
if (ObjectUtil.isNull(tag)) {
//未绑定
SimpleTagDto dto = baseMapper.getInitTagInfo(req.getBatchId());
if (ObjectUtil.isNull(dto)) {
throw new ServiceException(ProductExceptionEnum.TAG_INFO_INIT_DONE);
}
tag = new ProductTag();
tag.setTagId(dto.getTagId());
tag.setProductCode(dto.getProductCode());
return tag;
} else {
//已绑定
//2-验证批次是否一致
if (StrUtil.equalsIgnoreCase(String.valueOf(req.getBatchId()),
String.valueOf(tag.getBatchId()))) {
return tag;
} else {
//抛出异常,标签已经绑定了
throw new ServiceException(ProductExceptionEnum.TAG_INFO_HAD_BINDING);
}
}
}
@Override
public ProductTag findByUid(String tagUid) {
ProductTagReq tmp = new ProductTagReq();
tmp.setTagUid(tagUid);
LambdaQueryWrapper<ProductTag> wp = createWrapper(tmp);
List<ProductTag> list = list(wp);
if (CollectionUtil.isNotEmpty(list)) {
return list.get(0);
} else {
return null;
}
}
@Override
public ProductTagDto getTagInfo(Long tagId) {
ProductTagDto dto = baseMapper.getTagInfoByTagId(tagId);
if (ObjectUtil.isNull(dto)) {
throw new ServiceException(ProductExceptionEnum.TAG_INFO_NOT_EXISTS);
}
return dto;
}
@Override
public List<ProductTag> findList(ProductTagReq req) {
LambdaQueryWrapper<ProductTag> wp = createWrapper(req);
return this.list(wp);
}
@Override
public PageResult<ProductTag> findPage(ProductTagReq req) {
LambdaQueryWrapper<ProductTag> wrapper = createWrapper(req);
Page<ProductTag> page = this.page(PageFactory.getDefaultPage(), wrapper);
return PageResultFactory.createPageResult(page);
}
private LambdaQueryWrapper<ProductTag> createWrapper(ProductTagReq req) {
LambdaQueryWrapper<ProductTag> wrapper = new LambdaQueryWrapper<>();
if (ObjectUtil.isEmpty(req)) {
return wrapper;
}
//根据业务编码查询
wrapper.eq(ObjectUtil.isNotEmpty(req.getProductCode()), ProductTag::getProductCode, req.getProductCode());
wrapper.eq(ObjectUtil.isNotEmpty(req.getTagUid()), ProductTag::getTagUid, req.getTagUid());
wrapper.eq(ObjectUtil.isNotEmpty(req.getBatchId()), ProductTag::getBatchId, req.getBatchId());
wrapper.eq(ObjectUtil.isNotEmpty(req.getTagId()), ProductTag::getTagId, req.getTagId());
wrapper.eq(ProductTag::getHasInit, true);
wrapper.orderByDesc(ProductTag::getCheckTime);
return wrapper;
}
}
<?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.junmp.gold.mapper.CompanyMapper">
<select id="getMaxSn" resultType="java.lang.Integer">
select ifnull(max(s1.sn), 0) as sn
from biz_company s1
</select>
</mapper>
<?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.junmp.gold.mapper.ProductBatchMapper">
<select id="getMaxSn" resultType="java.lang.Integer">
select ifnull(max(s1.sn), 0) as sn
from biz_product_batch s1
</select>
<select id="getBatchProcess" resultType="com.junmp.gold.api.bean.dto.ProductBatchDto">
select *
from v_product_batch_process
where batchId = #{batchId}
</select>
<select id="getBatchPage" resultType="com.junmp.gold.api.bean.dto.ProductBatchDto">
select * from v_product_batch_process s1 where 1=1
<if test="null != batch">
<if test="null != batch.batchId">
and s1.batchId = #{batch.batchId}
</if>
<if test="null != batch.productId">
and s1.productId = #{batch.productId}
</if>
<if test="null != batch.specId">
and s1.specId = #{batch.specId}
</if>
<if test="null != batch.batchNo">
and s1.batchNo like concat('%',#{batch.batchNo},'%')
</if>
</if>
order by s1.createTime desc
</select>
<select id="getBatchProcessPage" resultType="com.junmp.gold.api.bean.dto.ProductProcessDto">
select * from v_product_batch_check s1 where 1=1
<if test="null != batch">
<if test="null != batch.batchId">
and s1.batchId = #{batch.batchId}
</if>
<if test="null != batch.productId">
and s1.productId = #{batch.productId}
</if>
<if test="null != batch.specId">
and s1.specId = #{batch.specId}
</if>
<if test="null != batch.batchNo">
and s1.batchNo like concat('%',#{batch.batchNo},'%')
</if>
</if>
order by s1.createTime desc
</select>
</mapper>
<?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.junmp.gold.mapper.ProductMapper">
<select id="getMaxSn" resultType="java.lang.Integer">
select ifnull(max(s1.sn), 0) as sn
from biz_product s1
</select>
</mapper>
<?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.junmp.gold.mapper.ProductSkuMapper">
<!-- 获取当前产品最大序号 -->
<select id="getMaxSn" resultType="java.lang.Integer">
select ifnull(max(s1.sn), 0) as sn
from biz_product_sku s1
where s1.product_id = #{productId}
</select>
<!-- 删除产品对应的号型 -->
<delete id="delByProductId">
delete
from biz_product_sku
where product_id = #{productId}
</delete>
</mapper>
<?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.junmp.gold.mapper.ProductTagMapper">
<!-- limit 0,1-->
<select id="getInitTagInfo" resultType="com.junmp.gold.api.bean.dto.SimpleTagDto">
select s1.tag_id as tagId,s1.product_code as productCode
from biz_product_tag s1
where s1.batch_id = #{batchId}
and s1.has_init = 0
order by s1.serial_id asc limit 0,1
</select>
<select id="getTagInfoByTagId" resultType="com.junmp.gold.api.bean.dto.ProductTagDto">
SELECT s1.tagId,
s1.productCode,
s1.produceTime,
s1.productName,
s1.spec,
s1.material,
s1.weight,
s1.companyName,
s1.password,
s1.ciphertext
FROM v_product_tag_info s1
WHERE s1.tagId = #{tagId}
</select>
</mapper>
package com.junmp.gold.boot;
import com.junmp.v2.db.starter.JpDataSourceAutoConfiguration;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2022/7/29 15:39
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@EnableScheduling
@EnableTransactionManagement
@SpringBootApplication(scanBasePackages = {"com.junmp"}, exclude = {FlywayAutoConfiguration.class,
JpDataSourceAutoConfiguration.class})
public class GoldBootApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(GoldBootApplication.class, args);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(GoldBootApplication.class);
}
}
package com.junmp.gold.boot.config;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
@Slf4j
@Configuration
public class GlobalCorsConfig {
@Bean
public CorsFilter corsFilter() {
//1.添加CORS配置信息
CorsConfiguration config = new CorsConfiguration();
//放行哪些原始域
config.addAllowedOrigin("*");
//是否发送Cookie信息
config.setAllowCredentials(false);
//放行哪些原始域(请求方式)
config.addAllowedMethod("*");
//放行哪些原始域(头部信息)
// config.addAllowedHeader("Accept,Origin,X-Request-With,Content-Type,Last-Modified,Access-Control-Request-Method,Access-Control-Request-Headers");
config.addAllowedHeader("*");
//暴露哪些头部信息(因为跨域访问默认不能获取全部头部信息)
config.addExposedHeader("Set-Cookie");
//2.添加映射路径
UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
configSource.registerCorsConfiguration("/**", config);
log.debug("GlobalCorsConfig valid");
//3.返回新的CorsFilter.
return new CorsFilter(configSource);
}
}
package com.junmp.gold.boot.config;
import cn.hutool.core.date.DatePattern;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.junmp.gold.boot.module.JpJacksonModule;
import org.springframework.boot.jackson.JsonComponent;
import org.springframework.context.annotation.Bean;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.TimeZone;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2021/12/29 9:00 上午
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@JsonComponent
public class JsonSerializerConfig {
@Bean
public MappingJackson2HttpMessageConverter getMappingJackson2HttpMessageConverter() {
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
//设置中文编码格式
List<MediaType> list = new ArrayList<>();
list.add(MediaType.APPLICATION_JSON);
converter.setSupportedMediaTypes(list);
converter.setObjectMapper(jacksonObjectMapper(new Jackson2ObjectMapperBuilder()));
return converter;
}
private ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
ObjectMapper objectMapper = builder.createXmlMapper(false).build();
//返回JSON的配置
objectMapper.setLocale(Locale.CHINA)
.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
//忽略未知字段
.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
.setTimeZone(TimeZone.getTimeZone(ZoneId.systemDefault()))
.setDateFormat(new SimpleDateFormat(DatePattern.NORM_DATETIME_PATTERN, Locale.CHINA));
//注册需要自动转换的类型
objectMapper.registerModule(new JpJacksonModule());
return objectMapper;
}
}
package com.junmp.gold.boot.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
/**
* <pre>
*
* 描述:
* 版本:1.0.0
* 日期:2021/6/18 1:33 下午
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Configuration
@MapperScan(basePackages = {"com.junmp.**.mapper"})
public class MapperScanConfiguration {
}
package com.junmp.gold.boot.core.handle;
import cn.hutool.core.util.StrUtil;
import com.junmp.v2.auth.api.exception.AuthException;
import com.junmp.v2.common.bean.response.ApiRes;
import com.junmp.v2.common.constant.SymbolConstant;
import com.junmp.v2.common.exception.base.ServiceException;
import com.junmp.v2.validator.api.exception.ParamValidateException;
import com.junmp.v2.validator.api.exception.ValidatorExceptionEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.HttpMediaTypeNotSupportedException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.servlet.NoHandlerFoundException;
import javax.servlet.http.HttpServletRequest;
import javax.validation.ValidationException;
import java.util.List;
/**
* <pre>
* TODO: 未实现
* 描述:全局异常处理器
* 版本:1.0.0
* 日期:2021/6/21 3:29 下午
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {
/**
* 请求参数缺失异常
*/
@ExceptionHandler(MissingServletRequestParameterException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes missingParam(MissingServletRequestParameterException e) {
String parameterName = e.getParameterName();
String parameterType = e.getParameterType();
log.error("请求参数异常>>[" + parameterName + "][" + parameterType + "]");
return ApiRes.failure(ValidatorExceptionEnum.MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION);
}
/**
* HttpMessageConverter转化异常,一般为json解析异常
*/
@ExceptionHandler(HttpMessageNotReadableException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes httpMessageNotReadable(HttpMessageNotReadableException httpMessageNotReadableException) {
log.error("参数格式传递异常,错误信息为:{}", httpMessageNotReadableException.getMessage());
return ApiRes.failure(ValidatorExceptionEnum.HTTP_MESSAGE_CONVERTER_ERROR);
}
/**
* 拦截不支持媒体类型异常
*/
@ExceptionHandler(HttpMediaTypeNotSupportedException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes httpMediaTypeNotSupport(HttpMediaTypeNotSupportedException httpMediaTypeNotSupportedException) {
log.error("参数格式传递异常,错误信息为:{}", httpMediaTypeNotSupportedException.getMessage());
return ApiRes.failure(ValidatorExceptionEnum.HTTP_MEDIA_TYPE_NOT_SUPPORT);
}
/**
* 不受支持的http method
*/
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes methodNotSupport(HttpServletRequest request) {
String httpMethod = request.getMethod().toUpperCase();
log.error("不支持的http请求方法>>" + httpMethod);
return ApiRes.failure(ValidatorExceptionEnum.HTTP_METHOD_NOT_SUPPORT);
}
/**
* 404找不到资源
*/
@ExceptionHandler(NoHandlerFoundException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes notFound(NoHandlerFoundException e) {
return ApiRes.failure(ValidatorExceptionEnum.NOT_FOUND);
}
/**
* 请求参数校验失败,拦截 @Valid 校验失败的情况
*/
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes methodArgumentNotValidException(MethodArgumentNotValidException e) {
String bindingResult = getArgNotValidMessage(e.getBindingResult());
log.error("绑定异常>>" + bindingResult);
return ApiRes.failure(ValidatorExceptionEnum.VALIDATED_RESULT_ERROR.getCode(),
StrUtil.format(ValidatorExceptionEnum.VALIDATED_RESULT_ERROR.getMessage(),bindingResult));
}
/**
* 请求参数校验失败,拦截 @Validated 校验失败的情况
* <p>
* 两个注解 @Valid 和 @Validated 区别是后者可以加分组校验,前者没有分组校验
*/
@ExceptionHandler(BindException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes bindException(BindException e) {
String bindingResult = getArgNotValidMessage(e.getBindingResult());
log.error("绑定异常>>" + bindingResult);
return ApiRes.failure(ValidatorExceptionEnum.VALIDATED_RESULT_ERROR);
}
/**
* 拦截 @TableUniqueValue 里抛出的异常
*/
@ExceptionHandler(ValidationException.class)
@ResponseBody
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ApiRes bindException(ValidationException e) {
if (e.getCause() instanceof ParamValidateException) {
ParamValidateException paramValidateException = (ParamValidateException) e.getCause();
return ApiRes.failure(paramValidateException.getCode(), paramValidateException.getMessage());
}
return ApiRes.failure(e.getMessage());
}
/**
* 拦截全校校验一类的异常
*/
@ExceptionHandler(AuthException.class)
//@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ResponseBody
public ApiRes authError(AuthException authException) {
log.error(">授权异常>>" + authException.getMessage());
if (null != authException) {
// 默认响应前端json
return ApiRes.failure(authException.getCode(), authException.getMessage());
} else {
return ApiRes.failure("");
}
}
/**
* 拦截业务代码抛出的异常
*/
@ExceptionHandler(ServiceException.class)
//@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ResponseBody
public ApiRes businessError(ServiceException e) {
log.error("业务异常,错误信息为:{}", e.getMessage());
return ApiRes.failure(e.getCode(), e.getMessage());
}
/**
* 拦截未知的运行时异常
*/
@ExceptionHandler(Throwable.class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ResponseBody
public ApiRes serverError(Throwable e) {
log.error("服务器运行异常", e);
return ApiRes.failure(e.getMessage());
}
/**
* 获取请求参数不正确的提示信息
* <p>
* 多个信息,拼接成用逗号分隔的形式
*/
private String getArgNotValidMessage(BindingResult bindingResult) {
if (bindingResult == null) {
return "";
}
StringBuilder stringBuilder = new StringBuilder();
//多个错误用逗号分隔
List<ObjectError> allErrorInfos = bindingResult.getAllErrors();
for (ObjectError error : allErrorInfos) {
stringBuilder.append(SymbolConstant.COMMA).append(error.getDefaultMessage());
}
//最终把首部的逗号去掉
return StrUtil.removePrefix(stringBuilder.toString(), SymbolConstant.COMMA);
}
}
package com.junmp.gold.boot.module;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUtil;
import com.fasterxml.jackson.core.json.PackageVersion;
import com.fasterxml.jackson.databind.deser.std.DateDeserializers;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.DateSerializer;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
/**
* <pre>
*
* 描述:配置JSON序列化和反序列化特殊类型
* 版本:1.0.0
* 日期:2022/5/27 10:32
* 作者:ningzp@junmp.com.cn
* <br>修改记录
* <br>修改日期 修改人 修改内容
*
* </pre>
*/
public class JpJacksonModule extends SimpleModule {
public JpJacksonModule() {
super(PackageVersion.VERSION);
this.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DatePattern.NORM_DATETIME_FORMATTER));
this.addSerializer(LocalDate.class, new LocalDateSerializer(DatePattern.NORM_DATE_FORMATTER));
this.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)));
this.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DatePattern.NORM_DATETIME_FORMATTER));
this.addDeserializer(LocalDate.class, new LocalDateDeserializer(DatePattern.NORM_DATE_FORMATTER));
this.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DatePattern.NORM_TIME_PATTERN)));
this.addSerializer(Date.class, new DateSerializer(false, DateUtil.newSimpleFormat(DatePattern.NORM_DATETIME_PATTERN)));
this.addDeserializer(Date.class, new DateDeserializers.DateDeserializer());
this.addSerializer(Long.class, ToStringSerializer.instance);
this.addSerializer(Long.TYPE, ToStringSerializer.instance);
this.addSerializer(BigInteger.class, ToStringSerializer.instance);
this.addSerializer(BigDecimal.class, ToStringSerializer.instance);
}
}
scanner:
open: false
# 配置第三方请求
junmp:
swagger:
base-package: com.junmp
id:
worker-id: 1
data-center-id: 1
epoch: 1656036996843
max: 9999
log:
type: db
ds: true #是否多数据源
knife4j:
enable: true
setting:
enableDebug: false
basic:
enable: true
username: ning
password: ning
spring:
datasource:
driver-class-name: com.p6spy.engine.spy.P6SpyDriver #com.mysql.cj.jdbc.Driver
url: jdbc:p6spy:mysql://localhost:13306/db_gold_app?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&serverTimezone=CTT&nullCatalogMeansCurrent=true
username: root
password: ning2022
redis:
host: localhost
port: 6379
database: 1
password: junmptech
scanner:
open: false
junmp:
swagger:
base-package: com.junmp
log:
type: db
bz:
config-storage:
knife4j:
enable: true
setting:
enableDebug: false
basic:
enable: true
username: ning
password: ning
spring:
datasource:
driver-class-name: org.postgresql.Driver
url: jdbc:postgresql://localhost:5432/chirpstack_as
username: junmp
password: junmp.com.cn
server:
port: 10030
spring:
main:
#bea同名类进行注册时,准许覆盖注册
allow-bean-definition-overriding: true
application:
name: gold-app
profiles:
active: @spring.active@
servlet:
multipart:
max-request-size: 200MB
max-file-size: 200MB
jackson:
time-zone: GMT+8
date-format: yyyy-MM-dd HH:mm:ss
locale: zh_CN
serialization:
indent_output: false
flyway:
enable: ture
locations: classpath:db/migration
# 当迁移时发现目标schema非空,而且带有没有元数据的表时,是否自动执行基准迁移
baseline-on-migrate: true
# 是否允许无序的迁移 开发环境最好开启, 生产环境关闭
out-of-order: true
# 关闭占位符替换,因为插入的sql里边可能包含${}关键字
placeholder-replacement: false
mybatis-plus:
configuration:
cache-enabled: true
lazy-loading-enabled: true
multiple-result-sets-enabled: true
map-underscore-to-camel-case: false
global-config:
banner: false
enable-sql-runner: true
db-config:
id-type: assign_id
table-underline: true
mapper-locations: classpath*:/mapper/**/*Mapper.xml
${AnsiColor.BRIGHT_YELLOW}
___ _____ _
|_ | |_ _| | |
| |_ _ _ __ _ __ ___ _ __ | | ___ ___| |__
| | | | | '_ \| '_ ` _ \| '_ \| |/ _ \/ __| '_ \
/\__/ / |_| | | | | | | | | | |_) | | __/ (__| | | |
\____/ \__,_|_| |_|_| |_| |_| .__/\_/\___|\___|_| |_|
| |
|_| 钧普科技,万物互联
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!--日志格式应用spring boot默认的格式,也可以自己更改-->
<include resource="org/springframework/boot/logging/logback/defaults.xml"/>
<!--定义日志存放的位置,默认存放在项目启动的相对路径的目录-->
<springProperty scope="context" name="LOG_PATH" source="log.path" defaultValue="app-log"/>
<!-- ****************************************************************************************** -->
<!-- ****************************** 本地开发只在控制台打印日志 ************************************ -->
<!-- ****************************************************************************************** -->
<springProfile name="local">
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${CONSOLE_LOG_PATTERN}</pattern>
<charset>utf-8</charset>
</encoder>
</appender>
<!--默认所有的包以info-->
<root level="info">
<appender-ref ref="STDOUT"/>
</root>
<!--本项目的日志级别-->
<logger name="org.springframework" level="ERROR"/>
<logger name="com.junmp" level="info" additivity="false">
<appender-ref ref="STDOUT"/>
</logger>
</springProfile>
<!-- ********************************************************************************************** -->
<!-- **** 放到服务器上不管在什么环境都只在文件记录日志,控制台(catalina.out)打印logback捕获不到的日志 **** -->
<!-- ********************************************************************************************** -->
<springProfile name="!local">
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${CONSOLE_LOG_PATTERN}</pattern>
<charset>utf-8</charset>
</encoder>
</appender>
<!-- 日志记录器,日期滚动记录 -->
<appender name="FILE_ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!-- 正在记录的日志文件的路径及文件名 -->
<file>${LOG_PATH}/log_error.log</file>
<!-- 日志记录器的滚动策略,按日期,按大小记录 -->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 归档的日志文件的路径,%d{yyyy-MM-dd}指定日期格式,%i指定索引 -->
<fileNamePattern>${LOG_PATH}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<!-- 除按日志记录之外,还配置了日志文件不能超过2M,若超过2M,日志文件会以索引0开始,
命名日志文件,例如log-error-2013-12-21.0.log -->
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>10MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<!-- 追加方式记录日志 -->
<append>true</append>
<!-- 日志文件的格式 -->
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<pattern>${FILE_LOG_PATTERN}</pattern>
<charset>utf-8</charset>
</encoder>
<!-- 此日志文件只记录error级别的 -->
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>error</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<!-- 日志记录器,日期滚动记录 -->
<appender name="FILE_ALL" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!-- 正在记录的日志文件的路径及文件名 -->
<file>${LOG_PATH}/log_total.log</file>
<!-- 日志记录器的滚动策略,按日期,按大小记录 -->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 归档的日志文件的路径,%d{yyyy-MM-dd}指定日期格式,%i指定索引 -->
<fileNamePattern>${LOG_PATH}/total/log-total-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<!-- 除按日志记录之外,还配置了日志文件不能超过2M,若超过2M,日志文件会以索引0开始,
命名日志文件,例如log-error-2013-12-21.0.log -->
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>10MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<!-- 追加方式记录日志 -->
<append>true</append>
<!-- 日志文件的格式 -->
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<pattern>${FILE_LOG_PATTERN}</pattern>
<charset>utf-8</charset>
</encoder>
</appender>
<!--记录到文件时,记录两类一类是error日志,一个是所有日志-->
<root level="info">
<appender-ref ref="STDOUT"/>
<appender-ref ref="FILE_ERROR"/>
<appender-ref ref="FILE_ALL"/>
</root>
</springProfile>
</configuration>
module.log=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
# \u81EA\u5B9A\u4E49\u65E5\u5FD7\u6253\u5370
logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
#\u65E5\u5FD7\u8F93\u51FA\u5230\u63A7\u5236\u53F0
appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
# \u4F7F\u7528\u65E5\u5FD7\u7CFB\u7EDF\u8BB0\u5F55 sql
#appender=com.p6spy.engine.spy.appender.Slf4JLogger
# \u8BBE\u7F6E p6spy driver \u4EE3\u7406
deregisterdrivers=true
# \u53D6\u6D88JDBC URL\u524D\u7F00
useprefix=true
# \u914D\u7F6E\u8BB0\u5F55 Log \u4F8B\u5916,\u53EF\u53BB\u6389\u7684\u7ED3\u679C\u96C6\u6709error,info,batch,debug,statement,commit,rollback,result,resultset.
excludecategories=info,debug,result,commit,resultset
# \u65E5\u671F\u683C\u5F0F
dateformat=yyyy-MM-dd HH:mm:ss
# \u5B9E\u9645\u9A71\u52A8\u53EF\u591A\u4E2A
driverlist=com.mysql.cj.jdbc.Driver
# \u662F\u5426\u5F00\u542F\u6162SQL\u8BB0\u5F55
outagedetection=true
# \u6162SQL\u8BB0\u5F55\u6807\u51C6 2 \u79D2
outagedetectioninterval=2
#
Markdown 格式
0%
您添加了 0 到此讨论。请谨慎行事。
请先完成此评论的编辑!
注册 或者 后发表评论