caojiahao/dev_caojiahao
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加ResultCode

Browse Source
This commit is contained in:
lifenlong 2021-07-01 11:17:18 +08:00
parent cce14b4794
commit 931276f72b
32 changed files with 198 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
buyer-api/src/main/java/cn/lili/controller/other/distribution/DistributionGoodsBuyerController.java
View File

@ -11,6 +11,7 @@ import cn.lili.modules.distribution.service.DistributionSelectedGoodsService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
@ -50,13 +51,25 @@ public class DistributionGoodsBuyerController {
}
@ApiOperation(value = "选择分销商品")
@ApiImplicitParam(name = "distributionGoodsId", value = "分销ID", required = true, dataType = "String", paramType = "path")
@ApiImplicitParams({
@ApiImplicitParam(name = "distributionGoodsId", value = "分销ID", required = true, dataType = "String", paramType = "path"),
@ApiImplicitParam(name = "checked", value = "是否选择", required = true, dataType = "boolean", paramType = "query")
})
@GetMapping(value = "/checked/{distributionGoodsId}")
public ResultMessage<Object> distributionCheckGoods(
@NotNull(message = "分销商品不能为空") @PathVariable("distributionGoodsId") String distributionGoodsId) {
if(distributionSelectedGoodsService.add(distributionGoodsId)){
return ResultUtil.success();
@NotNull(message = "分销商品不能为空") @PathVariable("distributionGoodsId") String distributionGoodsId,Boolean checked) {
Boolean result=false;
if(checked){
result=distributionSelectedGoodsService.add(distributionGoodsId);
}else {
result=distributionSelectedGoodsService.delete(distributionGoodsId);
}
throw new ServiceException(ResultCode.ERROR);
//判断操作结果
if(result){
return ResultUtil.success(ResultCode.SUCCESS);
}else{
throw new ServiceException(ResultCode.ERROR);
}
}
}

2
common-api/src/main/java/cn/lili/controller/common/UploadController.java
View File

@ -100,7 +100,7 @@ public class UploadController {
fileService.save(newFile);
} catch (Exception e) {
log.error("文件上传失败", e);
throw new ServiceException(ResultCode.OSS_EXCEPTION);
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
}
return ResultUtil.data(result);
}

214
framework/src/main/java/cn/lili/common/enums/ResultCode.java
View File

@ -27,25 +27,15 @@ public enum ResultCode {
* 参数异常
*/
PARAMS_ERROR(4002, "参数异常"),
/**
* 非法请求
*/
ILLEGAL_REQUEST_ERROR(4003, "非法请求，请重新刷新页面操作"),
/**
* 高频访问错误
*/
LIMIT_ERROR(4004,"访问过于频繁，请稍后再试"),
/**
* 系统异常
*/
WECHAT_CONNECT_NOT_EXIST(1001, "微信联合登录未配置"),
VERIFICATION_EXIST(1002, "验证码服务异常"),
LIMIT_ERROR(1003,"访问过于频繁，请稍后再试"),
ILLEGAL_REQUEST_ERROR(1004, "非法请求，请重新刷新页面操作"),
/**
* 分类
*/
@ -58,6 +48,7 @@ public enum ResultCode {
CATEGORY_SAVE_ERROR(10007, "此类别下存在商品不能删除"),
CATEGORY_PARAMETER_SAVE_ERROR(10008, "分类绑定参数组添加失败"),
CATEGORY_PARAMETER_UPDATE_ERROR(10009, "分类绑定参数组添加失败"),
CATEGORY_DELETE_FLAG_ERROR(10010, "子类状态不能与父类不一致！"),
/**
* 商品
@ -77,181 +68,124 @@ public enum ResultCode {
GOODS_SKU_QUANTITY_NOT_ENOUGH(11011, "商品库存不足"),
MUST_HAVE_GOODS_SKU(11012,"规格必须要有一个！"),
GOODS_PARAMS_ERROR(11013,"商品参数错误，刷新后重试"),
PHYSICAL_GOODS_NEED_TEMP(11014,"实物商品需选择配送模板"),
VIRTUAL_GOODS_NOT_NEED_TEMP(11015,"实物商品需选择配送模板"),
GOODS_TYPE_ERROR(11016, "需选择商品类型"),
/**
* 参数
*/
PARAMETER_SAVE_ERROR(12001, "参数添加失败"),
PARAMETER_UPDATE_ERROR(12002, "参数编辑失败"),
/**
* 规格
*/
SPEC_SAVE_ERROR(13001, "规格修改失败"),
SPEC_UPDATE_ERROR(13002, "规格修改失败"),
SPEC_DELETE_ERROR(13003, "此规格已绑定分类不允许删除"),
/**
* 品牌
*/
BRAND_SAVE_ERROR(14001, "品牌添加失败"),
BRAND_UPDATE_ERROR(14002, "品牌修改失败"),
BRAND_DISABLE_ERROR(14003, "品牌禁用失败"),
BRAND_DELETE_ERROR(14004, "品牌删除失败"),
BRAND_NAME_EXIST_ERROR(20002, "品牌名称重复！"),
BRAND_USE_DISABLE_ERROR(20003, "当前品牌下存在分类不可禁用"),
BRAND_NOT_EXIST(20004, "品牌不存在"),
/**
* 用户
*/
USER_EDIT_SUCCESS(20001, "用户修改成功"),
USER_NOT_EXIST(20002, "用户不存在"),
USER_NOT_LOGIN(20003, "用户未登录"),
USER_AUTH_EXPIRED(20004, "用户已退出，请重新登录"),
USER_AUTHORITY_ERROR(20005, "权限不足"),
USER_CONNECT_LOGIN_ERROR(20006, "未找到登录信息"),
USER_NAME_EXIST(20007, "该用户名已被注册"),
USER_PHONE_EXIST(20008, "该手机号已被注册"),
USER_PHONE_NOT_EXIST(20009, "手机号不存在"),
USER_PASSWORD_ERROR(20010, "密码不正确"),
USER_NOT_PHONE(20011, "非当前用户的手机号"),
USER_CONNECT_ERROR(20012, "联合第三方登录，授权信息错误"),
USER_RECEIPT_REPEAT_ERROR(20013, "会员发票信息重复"),
USER_RECEIPT_NOT_EXIST(20014, "会员发票信息不存在"),
USER_EDIT_ERROR(20015, "用户修改失败"),
USER_OLD_PASSWORD_ERROR(20016, "旧密码不正确"),
USER_COLLECTION_EXIST(20017, "无法重复收藏"),
USER_GRADE_IS_DEFAULT(20018, "会员等级为默认会员等级"),
DELETE_EXIST(20019, "无法重复收藏"),
NOT_BINDING_USER(20020,"未绑定用户"),
USER_NOT_BINDING(20020,"未绑定用户"),
USER_AUTO_REGISTER_ERROR(20021,"自动注册失败,请稍后重试"),
USER_OVERDUE_CONNECT_ERROR(20022,"授权信息已过期，请重新授权/登录"),
USER_CONNECT_BANDING_ERROR(20023,"当前联合登陆方式，已绑定其他账号，需进行解绑操作"),
USER_CONNECT_NOT_EXIST_ERROR(20024, "暂无联合登陆信息，无法实现一键注册功能，请点击第三方登录进行授权"),
/**
* 权限
*/
PERMISSION_DEPARTMENT_ROLE_ERROR(21001, "角色已绑定部门，请逐个删除"),
PERMISSION_USER_ROLE_ERROR(21002, "角色已绑定管理员，请逐个删除"),
PERMISSION_MENU_ROLE_ERROR(21003, "菜单已绑定角色，请先删除或编辑角色"),
PERMISSION_DEPARTMENT_DELETE_ERROR(21004, "部门已经绑定管理员，请先删除或编辑管理员"),
PERMISSION_BEYOND_TEN(21005, "最多可以设置10个角色"),
/**
* 分销
*/
DISTRIBUTION_CLOSE(22000, "分销功能关闭"),
DISTRIBUTION_NOT_EXIST(22001, "分销员不存在"),
DISTRIBUTION_IS_APPLY(22002, "分销员已申请，无需重复提交"),
DISTRIBUTION_AUDIT_ERROR(22003, "审核分销员失败"),
DISTRIBUTION_RETREAT_ERROR(22004, "分销员清退失败"),
DISTRIBUTION_CASH_NOT_EXIST(22005, "分销员提现记录不存在"),
DISTRIBUTION_GOODS_DOUBLE(22006, "不能重复添加分销商品"),
/**
* 购物车
*/
CART_ERROR(30001, "读取结算页的购物车异常"),
CART_PINTUAN_NOT_EXIST_ERROR(30002, "拼团活动不存在错误"),
CART_PINTUAN_LIMIT_ERROR(30003, "购买数量超过拼团活动限制数量"),
SHIPPING_NOT_APPLY(30005, "购物商品不支持当前收货地址配送"),
/**
* 订单
*/
ORDER_ERROR(31001, "创建订单异常，请稍后重试"),
ORDER_NOT_EXIST(31002, "订单不存在"),
ORDER_DELIVERED_ERROR(31003, "订单状态错误，无法进行确认收货"),
ORDER_UPDATE_PRICE_ERROR(31004, "已支付的订单不能修改金额"),
ORDER_LOGISTICS_ERROR(31005, "物流错误"),
ORDER_DELIVER_ERROR(31006, "物流错误"),
ORDER_NOT_USER(31007, "非当前会员的订单"),
ORDER_TAKE_ERROR(31008, "当前订单无法核销"),
MEMBER_ADDRESS_NOT_EXIST(31009, "订单无收货地址，请先配置收货地址"),
ORDER_DELIVER_NUM_ERROR(31010, "没有待发货的订单"),
ORDER_NOT_SUPPORT_DISTRIBUTION(31011, "购物车中包含不支持配送的商品，请重新选择收货地址，或者重新选择商品"),
ORDER_CAN_NOT_CANCEL(31012, "当前订单状态不可取消"),
BATCH_DELIVER_ERROR(31013, "批量发货,文件读取失败"),
ORDER_BATCH_DELIVER_ERROR(31013, "批量发货,文件读取失败"),
ORDER_ITEM_NOT_EXIST(31014, "当前订单项不存在！"),
/**
* 支付
*/
PAY_UN_WANTED(32000, "当前订单不需要付款，返回订单列表等待系统订单出库即可"),
PAY_SUCCESS(32001, "支付成功"),
PAY_INCONSISTENT_ERROR(32002, "付款金额和应付金额不一致"),
PAY_DOUBLE_ERROR(32003, "订单已支付，不能再次进行支付"),
PAY_CASHIER_ERROR(32004, "收银台信息获取错误"),
PAY_ERROR(32005, "支付业务异常，请稍后重试"),
PAY_BAN(32006, "当前订单不需要付款，请返回订单列表重新操作"),
PAY_PARTIAL_ERROR(32007, "该订单已部分支付，请前往订单中心进行支付"),
PAY_NOT_SUPPORT(32008, "支付暂不支持"),
PAY_CLIENT_TYPE_ERROR(32009, "错误的客户端"),
PAY_POINT_ENOUGH(32010, "积分不足，不能兑换"),
PAY_NOT_EXIST_ORDER(32011, "支付订单不存在"),
CAN_NOT_RECHARGE_WALLET(32012, "不能使用余额进行充值"),
@ -259,39 +193,32 @@ public enum ResultCode {
* 售后
*/
AFTER_SALES_NOT_PAY_ERROR(33001, "当前订单未支付，不能申请售后"),
AFTER_SALES_CANCEL_ERROR(33002, "当前售后单无法取消"),
AFTER_SALES_BAN(33003, "订单状态不允许申请售后，请联系平台或商家"),
AFTER_SALES_DOUBLE_ERROR(33004, "售后已审核，无法重复操作"),
AFTER_SALES_LOGISTICS_ERROR(33005, "物流公司错误，请重新选择"),
AFTER_STATUS_ERROR(33006, "售后状态错误，请刷新页面"),
RETURN_MONEY_OFFLINE_BANK_ERROR(33007, "当账号类型为银行转账时，银行信息不能为空"),
/**
* 投诉
*/
COMPLAINT_ORDER_ITEM_EMPTY_ERROR(33100, "订单不存在"),
COMPLAINT_SKU_EMPTY_ERROR(33101, "商品已下架，如需投诉请联系平台客服"),
COMPLAINT_ERROR(33102, "投诉异常，请稍后重试"),
COMPLAINT_NOT_EXIT(33103, "当前投诉记录不存在"),
COMPLAINT_ARBITRATION_RESULT_ERROR(33104, "结束订单投诉时，仲裁结果不能为空"),
COMPLAINT_APPEAL_CONTENT_ERROR(33105, "商家申诉时，申诉内容不能为空"),
/**
* 余额
*/
WALLET_NOT_EXIT_ERROR(34000, "钱包不存在，请联系管理员"),
WALLET_INSUFFICIENT(34001, "余额不足以支付订单，请充值!"),
WALLET_WITHDRAWAL_INSUFFICIENT(34002, "可提现金额不足！"),
WALLET_ERROR_INSUFFICIENT(34003, "零钱提现失败！"),
WALLET_REMARK_ERROR(34004, "请填写审核备注！"),
WALLET_APPLY_ERROR(34005, "提现申请异常！"),
/**
@ -300,62 +227,68 @@ public enum ResultCode {
EVALUATION_DOUBLE_ERROR(35001, "无法重复提交评价"),
/**
* 签到
* 活动
*/
MEMBER_SIGN_REPEAT(40001, "请勿重复签到"),
PROMOTION_GOODS_NOT_EXIT(40001, "当前促销商品不存在！"),
PROMOTION_SAME_ACTIVE_EXIST(40002,"当前时间内已存在同类活动"),
PROMOTION_START_TIME_ERROR(40003,"活动起始时间不能大于活动结束时间"),
PROMOTION_TIME_ERROR(40004,"活动起始时间必须大于当前时间"),
PROMOTION_SAME_ERROR(40005,"当前时间段已存在相同活动！"),
PROMOTION_GOODS_ERROR(40006,"请选择要参与活动的商品"),
PROMOTION_STATUS_END(40007,"当前活动已停止"),
PROMOTION_UPDATE_ERROR(40008,"当前活动已开始/结束，无法编辑！"),
/**
* 优惠券
*/
COUPON_EDIT_STATUS_SUCCESS(41001, "修改状态成功！"),
COUPON_CANCELLATION_SUCCESS(41002, "会员优惠券作废成功"),
COUPON_EXPIRED(41003, "优惠券已使用/已过期，不能使用"),
COUPON_EDIT_STATUS_ERROR(41004, "优惠券修改状态失败！"),
COUPON_RECEIVE_ERROR(41005, "当前优惠券状态不可领取"),
COUPON_NUM_INSUFFICIENT_ERROR(41006, "优惠券剩余领取数量不足"),
COUPON_NOT_EXIST(41007, "当前优惠券不存在"),
COUPON_LIMIT_NUM_LESS_THAN_0(41008, "领取限制数量不能为负数"),
COUPON_LIMIT_GREATER_THAN_PUBLISH(41009, "领取限制数量超出发行数量"),
COUPON_DISCOUNT_ERROR(41010, "优惠券折扣必须小于10且大于0"),
COUPON_SCOPE_TYPE_GOODS_ERROR(41011, "当前关联范围类型为指定商品时，商品列表不能为空"),
COUPON_SCOPE_TYPE_CATEGORY_ERROR(41012, "当前关联范围类型为部分商品分类时，范围关联的id不能为空"),
COUPON_SCOPE_TYPE_STORE_ERROR(41013, "当前关联范围类型为部分店铺分类时，范围关联的id不能为空"),
COUPON_SCOPE_ERROR(41014, "指定商品范围关联id无效！"),
COUPON_MEMBER_NOT_EXIST(41015, "没有当前会员优惠券"),
COUPON_MEMBER_STATUS_ERROR(41016, "当前会员优惠券已过期/作废无法变更状态！"),
/**
* 拼团
*/
PINTUAN_MANUAL_OPEN_SUCCESS(42001, "手动开启拼团活动成功"),
PINTUAN_MANUAL_CLOSE_SUCCESS(42002, "手动关闭拼团活动成功"),
PINTUAN_ADD_SUCCESS(42003, "添加拼团活动成功"),
PINTUAN_EDIT_SUCCESS(42004, "修改拼团活动成功"),
PINTUAN_DELETE_SUCCESS(42005, "删除拼团活动成功"),
PINTUAN_MANUAL_OPEN_ERROR(42006, "手动开启拼团活动失败"),
PINTUAN_MANUAL_CLOSE_ERROR(42007, "手动关闭拼团活动失败"),
PINTUAN_ADD_ERROR(42008, "添加拼团活动失败"),
PINTUAN_EDIT_ERROR(42009, "修改拼团活动失败"),
PINTUAN_DELETE_ERROR(42010, "删除拼团活动失败"),
PINTUAN_JOIN_ERROR(42011, "不能参与自己发起的拼团活动！"),
PINTUAN_LIMIT_NUM_ERROR(42012, "购买数量超过拼团活动限制数量！"),
PINTUAN_NOT_EXIST_ERROR(42013,"当前拼团商品不存在！"),
/**
* 满额活动
*/
FULL_DISCOUNT_EDIT_SUCCESS(43001, "修改满优惠活动成功"),
FULL_DISCOUNT_EDIT_DELETE(43002, "删除满优惠活动成功"),
FULL_DISCOUNT_MODIFY_ERROR(43003,"当前编辑的满优惠活动已经开始或者已经结束，无法修改"),
FULL_DISCOUNT_NOT_EXIST_ERROR(43004,"当前要操作的满优惠活动不存在！"),
FULL_DISCOUNT_WAY_ERROR(43005,"请选择一种优惠方式！"),
FULL_DISCOUNT_GIFT_ERROR(43006,"请选择赠品！"),
FULL_DISCOUNT_COUPON_TIME_ERROR(43007,"赠送的优惠券有效时间必须大于活动时间"),
FULL_DISCOUNT_MONEY_ERROR(43008,"请填写满减金额"),
FULL_DISCOUNT_MONEY_GREATER_THAN_MINUS(43009,"满减金额不能大于优惠门槛"),
FULL_RATE_NUM_ERROR(43010,"请填写打折数值"),
/**
* 直播
@ -370,6 +303,8 @@ public enum ResultCode {
SECKILL_UPDATE_ERROR(45002,"当前秒杀活动活动已经开始，无法修改！"),
SECKILL_PRICE_ERROR(45003,"活动价格不能大于商品原价"),
SECKILL_TIME_ERROR(45004,"时刻参数异常"),
SECKILL_DELETE_ERROR(45005,"该秒杀活动活动的状态不能删除"),
SECKILL_CLOSE_ERROR(45006,"该秒杀活动活动的状态不能关闭"),
/**
@ -381,40 +316,36 @@ public enum ResultCode {
COUPON_ACTIVITY_ITEM_MUST_NUM_ERROR(46004,"优惠券活动最多指定10个优惠券"),
COUPON_ACTIVITY_ITEM_NUM_ERROR(46005,"赠券数量必须大于0"),
/**
* 其他促销
*/
MEMBER_SIGN_REPEAT(47001, "请勿重复签到"),
POINT_GOODS_ACTIVE_STOCK_ERROR(47002, "活动库存数量不能高于商品库存"),
/**
* 店铺
*/
STORE_NOT_EXIST(50001, "此店铺不存在"),
STORE_NAME_EXIST_ERROR(50002, "店铺名称已存在!"),
STORE_APPLY_DOUBLE_ERROR(50003, "已有店铺，无需重复申请!"),
STORE_NOT_OPEN(50004, "该会员未开通店铺"),
STORE_NOT_LOGIN_ERROR(50005, "未登录店铺"),
/**
* 结算单
*/
BILL_CHECK_ERROR(51001, "只有已出账结算单可以核对"),
BILL_COMPLETE_ERROR(51002, "只有已审核结算单可以支付"),
/**
* 文章
*/
ARTICLE_CATEGORY_NAME_EXIST(60001, "文章分类名称已存在"),
ARTICLE_CATEGORY_PARENT_NOT_EXIST(60002, "文章分类父分类不存在"),
ARTICLE_CATEGORY_BEYOND_TWO(60003, "最多为二级分类,操作失败"),
ARTICLE_CATEGORY_DELETE_ERROR(60004, "该文章分类下存在子分类，不能删除"),
ARTICLE_CATEGORY_HAS_ARTICLE(60005, "该文章分类下存在文章，不能删除"),
ARTICLE_CATEGORY_NO_DELETION(60007, "默认文章分类不能进行删除"),
ARTICLE_NO_DELETION(60008, "默认文章不能进行删除"),
@ -422,79 +353,66 @@ public enum ResultCode {
* 页面
*/
PAGE_NOT_EXIST(61001, "页面不存在"),
PAGE_OPEN_DELETE_ERROR(61002, "当前页面为开启状态，无法删除"),
PAGE_DELETE_ERROR(61003, "当前页面为唯一页面，无法删除"),
PAGE_RELEASE_ERROR(61004, "页面已发布，无需重复提交"),
/**
* 设置
*/
SETTING_NOT_TO_SET(70001, "该参数不需要设置"),
ALIPAY_NOT_SETTING(70002, "支付宝支付未配置"),
ALIPAY_EXCEPTION(70003, "支付宝支付错误，请稍后重试"),
ALIPAY_PARAMS_EXCEPTION(70004, "支付宝参数异常"),
LOGISTICS_NOT_SETTING(70005,"您还未配置快递查询"),
ORDER_SETTING_ERROR(70006,"系统订单配置异常"),
ALI_SMS_SETTING_ERROR(70007,"您还未配置阿里云短信"),
SMS_SIGN_EXIST_ERROR(70008, "短信签名已存在"),
/**
* 站内信
*/
NOTICE_NOT_EXIST(80001, "当前消息模板不存在"),
NOTICE_ERROR(80002, "修改站内信异常，请稍后重试"),
NOTICE_SEND_ERROR(80003, "发送站内信异常，请检查系统日志"),
/**
* OSS
*/
OSS_NOT_EXIST(80101, "OSS未配置"),
OSS_EXCEPTION(80102, "文件上传失败，请稍后重试"),
OSS_EXCEPTION_ERROR(80102, "文件上传失败，请稍后重试"),
OSS_DELETE_ERROR(80102, "图片删除失败"),
/**
* 验证码
*/
VERIFICATION_SEND_SUCCESS(80201, "短信验证码,发送成功"),
VERIFICATION_ERROR(80202, "验证失败"),
VERIFICATION_SMS_ERROR(80203, "短信验证码错误，请重新校验"),
VERIFICATION_SMS_EXPIRED_ERROR(80204, "验证码已失效，请重新校验"),
/**
* 微信相关异常
*/
WECHAT_CONNECT_NOT_SETTING(80300, "微信联合登陆信息未配置"),
WECHAT_PAYMENT_NOT_SETTING(80301, "微信支付信息未配置"),
WECHAT_QRCODE_ERROR(80302, "微信二维码生成异常"),
WECHAT_MP_MESSAGE_ERROR(80303, "微信小程序小消息订阅异常"),
WECHAT_JSAPI_SIGN_ERROR(80304,"微信JsApi签名异常"),
WECHAT_CERT_ERROR(80305,"证书获取失败"),
WECHAT_MP_MESSAGE_TMPL_ERROR(80306,"未能获取到微信模版消息id"),
WECHAT_ERROR(80307,"微信接口异常"),
APP_VERSION_EXIST(80307, "APP版本已存在"),
WECHAT_CERT_ERROR(80505,"证书获取失败"),
APP_VERSION_EXIST(80600, "APP版本已存在"),
/**
* 其他
*/
CUSTOM_WORDS_EXIST_ERROR(90000, "当前自定义分词已存在！"),
CUSTOM_WORDS_NOT_EXIST_ERROR(90000, "当前自定义分词不存在！"),
CUSTOM_WORDS_NOT_EXIST_ERROR(90001, "当前自定义分词不存在！"),
CUSTOM_WORDS_SECRET_KEY_ERROR(90002, "秘钥验证失败！"),
CONNECT_NOT_EXIST(90000,"登录方式不存在"),
;
private final Integer code;

2
framework/src/main/java/cn/lili/modules/connect/serviceimpl/ConnectServiceImpl.java
View File

@ -108,7 +108,7 @@ public class ConnectServiceImpl extends ServiceImpl<ConnectMapper, Connect> impl
CookieUtil.addCookie(CONNECT_TYPE, type, 1800, ThreadContextHolder.getHttpResponse());
//自动登录失败，则把信息缓存起来
cache.put(ConnectService.cacheKey(type, uuid), authUser, 30L, TimeUnit.MINUTES);
throw new ServiceException(ResultCode.NOT_BINDING_USER);
throw new ServiceException(ResultCode.USER_NOT_BINDING);
}
} catch (Exception e) {
log.error("联合登陆异常：", e);

7
framework/src/main/java/cn/lili/modules/distribution/service/DistributionSelectedGoodsService.java
View File

@ -16,4 +16,11 @@ public interface DistributionSelectedGoodsService extends IService<DistributionS
* @return
*/
boolean add(String distributionGoodsId);
/**
* 分销员添加分销商品
* @param distributionGoodsId 分销商品ID
* @return
*/
boolean delete(String distributionGoodsId);
}

12
framework/src/main/java/cn/lili/modules/distribution/serviceimpl/DistributionSelectedGoodsServiceImpl.java
View File

@ -4,6 +4,7 @@ import cn.lili.modules.distribution.entity.dos.DistributionSelectedGoods;
import cn.lili.modules.distribution.mapper.DistributionSelectedGoodsMapper;
import cn.lili.modules.distribution.service.DistributionSelectedGoodsService;
import cn.lili.modules.distribution.service.DistributionService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
@ -32,4 +33,15 @@ public class DistributionSelectedGoodsServiceImpl extends ServiceImpl<Distributi
DistributionSelectedGoods distributionSelectedGoods=new DistributionSelectedGoods(distributionId,distributionGoodsId);
return this.save(distributionSelectedGoods);
}
@Override
public boolean delete(String distributionGoodsId) {
//检查分销功能开关
distributionService.checkDistributionSetting();
String distributionId=distributionService.getDistribution().getId();
return this.remove(new LambdaQueryWrapper<DistributionSelectedGoods>()
.eq(DistributionSelectedGoods::getDistributionGoodsId,distributionGoodsId)
.eq(DistributionSelectedGoods::getDistributionId,distributionId));
}
}

15
framework/src/main/java/cn/lili/modules/file/plugin/impl/AliFileManagerPlugin.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.file.plugin.impl;
import cn.hutool.core.util.StrUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.modules.file.plugin.FileManagerPlugin;
import cn.lili.modules.system.entity.dos.Setting;
@ -76,7 +77,7 @@ public class AliFileManagerPlugin implements FileManagerPlugin {
if (ossSetting == null || nextInitSetting == null || nextInitSetting < System.currentTimeMillis()) {
Setting setting = settingService.get(SettingEnum.OSS_SETTING.name());
if (setting == null || StrUtil.isBlank(setting.getSettingValue())) {
throw new ServiceException("您还未配置阿里云OSS存储");
throw new ServiceException(ResultCode.OSS_NOT_EXIST);
}
nextInitSetting = System.currentTimeMillis() + interval;
ossSetting = new Gson().fromJson(setting.getSettingValue(), OssSetting.class);
@ -107,13 +108,13 @@ public class AliFileManagerPlugin implements FileManagerPlugin {
log.error("Error Code: " + oe.getErrorCode());
log.error("Request ID: " + oe.getRequestId());
log.error("Host ID: " + oe.getHostId());
throw new ServiceException("图片上传失败" + oe.getErrorMessage());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} catch (ClientException ce) {
log.error("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
log.error("Error Message: " + ce.getMessage());
throw new ServiceException("图片上传失败" + ce.getErrorMessage());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} finally {
/*
* Do not forget to shut down the client finally to release all allocated resources.
@ -138,13 +139,13 @@ public class AliFileManagerPlugin implements FileManagerPlugin {
log.error("Error Code: " + oe.getErrorCode());
log.error("Request ID: " + oe.getRequestId());
log.error("Host ID: " + oe.getHostId());
throw new ServiceException("图片上传失败" + oe.getErrorMessage());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} catch (ClientException ce) {
log.error("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
log.error("Error Message: " + ce.getMessage());
throw new ServiceException("图片上传失败" + ce.getErrorMessage());
throw new ServiceException(ResultCode.OSS_EXCEPTION_ERROR);
} finally {
/*
* Do not forget to shut down the client finally to release all allocated resources.
@ -169,13 +170,13 @@ public class AliFileManagerPlugin implements FileManagerPlugin {
log.error("Error Code: " + oe.getErrorCode());
log.error("Request ID: " + oe.getRequestId());
log.error("Host ID: " + oe.getHostId());
throw new ServiceException("图片删除失败" + oe.getErrorMessage());
throw new ServiceException(ResultCode.OSS_DELETE_ERROR);
} catch (ClientException ce) {
log.error("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
log.error("Error Message: " + ce.getMessage());
throw new ServiceException("图片删除失败" + ce.getErrorMessage());
throw new ServiceException(ResultCode.OSS_DELETE_ERROR);
} finally {
/*
* Do not forget to shut down the client finally to release all allocated resources.

3
framework/src/main/java/cn/lili/modules/goods/serviceimpl/CategoryServiceImpl.java
View File

@ -3,6 +3,7 @@ package cn.lili.modules.goods.serviceimpl;
import cn.hutool.core.util.StrUtil;
import cn.lili.common.cache.Cache;
import cn.lili.common.cache.CachePrefix;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.modules.goods.entity.dos.Category;
import cn.lili.modules.goods.entity.dos.CategoryParameterGroup;
@ -174,7 +175,7 @@ public class CategoryServiceImpl extends ServiceImpl<CategoryMapper, Category> i
if (category.getParentId() != null && !category.getParentId().equals("0")) {
Category parentCategory = this.getById(category.getParentId());
if (!parentCategory.getDeleteFlag().equals(category.getDeleteFlag())) {
throw new ServiceException("子类状态不能与父类不一致！");
throw new ServiceException(ResultCode.CATEGORY_DELETE_FLAG_ERROR);
}
}
UpdateWrapper<Category> updateWrapper = new UpdateWrapper<>();

8
framework/src/main/java/cn/lili/modules/goods/serviceimpl/GoodsServiceImpl.java
View File

@ -395,16 +395,16 @@ public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements
switch (goods.getGoodsType()) {
case "PHYSICAL_GOODS":
if (goods.getTemplateId().equals("0")) {
throw new ServiceException("实物商品需选择配送模板");
throw new ServiceException(ResultCode.PHYSICAL_GOODS_NEED_TEMP);
}
break;
case "VIRTUAL_GOODS":
if (!goods.getTemplateId().equals("0")) {
throw new ServiceException("虚拟商品不需要选择配送模板");
throw new ServiceException(ResultCode.VIRTUAL_GOODS_NOT_NEED_TEMP);
}
break;
default:
throw new ServiceException("需选择商品类型");
throw new ServiceException(ResultCode.GOODS_TYPE_ERROR);
}
//检查商品是否存在--修改商品时使用
if (goods.getId() != null) {
@ -435,7 +435,7 @@ public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements
goods.setStoreName(storeDetail.getStoreName());
goods.setSelfOperated(storeDetail.getSelfOperated());
} else {
throw new ServiceException("当前未登录店铺");
throw new ServiceException(ResultCode.STORE_NOT_LOGIN_ERROR);
}
}

3
framework/src/main/java/cn/lili/modules/member/serviceimpl/MemberNoticeSenterServiceImpl.java
View File

@ -1,5 +1,6 @@
package cn.lili.modules.member.serviceimpl;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.StringUtils;
import cn.lili.modules.member.entity.dos.MemberNoticeSenter;
@ -78,7 +79,7 @@ public class MemberNoticeSenterServiceImpl extends ServiceImpl<MemberNoticeSente
if (memberNoticeService.saveBatch(memberNotices)) {
return true;
} else {
throw new ServiceException("发送站内信异常，请检查系统日志");
throw new ServiceException(ResultCode.NOTICE_SEND_ERROR);
}
}
}

8
framework/src/main/java/cn/lili/modules/member/serviceimpl/MemberServiceImpl.java
View File

@ -190,7 +190,7 @@ public class MemberServiceImpl extends ServiceImpl<MemberMapper, Member> impleme
throw e;
} catch (Exception e) {
log.error("自动注册异常：", e);
throw new ServiceException("自动注册失败,请稍后重试");
throw new ServiceException(ResultCode.USER_AUTO_REGISTER_ERROR);
}
}
@ -529,7 +529,7 @@ public class MemberServiceImpl extends ServiceImpl<MemberMapper, Member> impleme
ConnectAuthUser connectAuthUser = getConnectAuthUser(uuid, connectType);
if (connectAuthUser == null) {
throw new ServiceException("授权信息已过期，请从新授权/登录");
throw new ServiceException(ResultCode.USER_OVERDUE_CONNECT_ERROR);
}
//检测是否已经绑定过用户
LambdaQueryWrapper<Connect> queryWrapper = new LambdaQueryWrapper<>();
@ -541,13 +541,13 @@ public class MemberServiceImpl extends ServiceImpl<MemberMapper, Member> impleme
connectAuthUser.setConnectEnum(authInterface);
return connectAuthUser;
} else {
throw new ServiceException("当前联合登陆方式，已绑定其他账号，需进行解绑操作");
throw new ServiceException(ResultCode.USER_CONNECT_BANDING_ERROR);
}
} catch (Exception e) {
throw e;
}
} else {
throw new ServiceException("暂无联合登陆信息，无法实现一键注册功能，请点击第三方登录进行授权");
throw new ServiceException(ResultCode.USER_CONNECT_NOT_EXIST_ERROR);
}
}

3
framework/src/main/java/cn/lili/modules/message/serviceimpl/WechatMPMessageServiceImpl.java
View File

@ -4,6 +4,7 @@ import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.modules.base.entity.enums.ClientTypeEnum;
import cn.lili.modules.message.entity.dos.WechatMPMessage;
@ -114,7 +115,7 @@ public class WechatMPMessageServiceImpl extends ServiceImpl<WechatMPMessageMappe
if (tplContent.containsKey("priTmplId")) {
wechatMPMessage.setCode(tplContent.getStr("priTmplId"));
} else {
throw new ServiceException("未能获取到微信模版消息id");
throw new ServiceException(ResultCode.WECHAT_MP_MESSAGE_TMPL_ERROR);
}
wechatMPMessage.setName(tplData.getSceneDesc());

3
framework/src/main/java/cn/lili/modules/message/serviceimpl/WechatMessageServiceImpl.java
View File

@ -3,6 +3,7 @@ package cn.lili.modules.message.serviceimpl;
import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.modules.base.entity.enums.ClientTypeEnum;
import cn.lili.modules.message.entity.dos.WechatMessage;
@ -83,7 +84,7 @@ public class WechatMessageServiceImpl extends ServiceImpl<WechatMessageMapper, W
if (tplContent.containsKey("template_id")) {
wechatMessage.setCode(tplContent.getStr("template_id"));
} else {
throw new ServiceException("未能获取到微信模版消息id");
throw new ServiceException(ResultCode.WECHAT_MP_MESSAGE_TMPL_ERROR);
}
wechatMessage.setName(tplData.getName());

6
framework/src/main/java/cn/lili/modules/message/util/WechatMessageUtil.java
View File

@ -3,6 +3,7 @@ package cn.lili.modules.message.util;
import cn.hutool.http.HttpUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.DateUtil;
import cn.lili.common.utils.StringUtils;
@ -276,12 +277,13 @@ public class WechatMessageUtil {
if (jsonObject.getStr("errmsg").equals("ok")) {
return;
}
throw new ServiceException("微信接口异常，请联系管理员：错误码" + jsonObject.get("errcode") + "，" + jsonObject.getStr("errmsg"));
log.error("微信接口异常，错误码" + jsonObject.get("errcode") + "，" + jsonObject.getStr("errmsg"));
throw new ServiceException(ResultCode.WECHAT_ERROR);
}
}
/**
* 如果返回信息有错误
* 如果返回信息有错误....................................................................................................................................................................................333333333333333333
*
* @param string
*/

3
framework/src/main/java/cn/lili/modules/order/cart/render/impl/CheckDataRender.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.order.cart.render.impl;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.security.context.UserContext;
import cn.lili.common.utils.CurrencyUtil;
@ -130,7 +131,7 @@ public class CheckDataRender implements CartRenderStep {
cn.lili.modules.order.order.entity.dos.Order parentOrder = orderService.getBySn(tradeDTO.getParentOrderSn());
//参与活动判定
if (parentOrder.getMemberId().equals(UserContext.getCurrentUser().getId())) {
throw new ServiceException("不能参与自己发起的拼团活动！");
throw new ServiceException(ResultCode.PINTUAN_JOIN_ERROR);
}
}
}

3
framework/src/main/java/cn/lili/modules/order/cart/render/impl/SkuPromotionRender.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.order.cart.render.impl;
import cn.hutool.core.date.DateUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.CurrencyUtil;
import cn.lili.common.utils.StringUtils;
@ -308,7 +309,7 @@ public class SkuPromotionRender implements CartRenderStep {
Integer limitNum = pintuan.getLimitNum();
for (CartSkuVO cartSkuVO : tradeDTO.getSkuList()) {
if (limitNum != 0 && cartSkuVO.getNum() > limitNum) {
throw new ServiceException("购买数量超过拼团活动限制数量");
throw new ServiceException(ResultCode.PINTUAN_LIMIT_NUM_ERROR);
}
}
}

2
framework/src/main/java/cn/lili/modules/order/order/serviceimpl/AfterSaleServiceImpl.java
View File

@ -473,7 +473,7 @@ public class AfterSaleServiceImpl extends ServiceImpl<AfterSaleMapper, AfterSale
|| StringUtils.isEmpty(afterSaleDTO.getBankAccountName())
|| StringUtils.isEmpty(afterSaleDTO.getBankAccountNumber());
if (emptyBankParam) {
throw new ServiceException("当账号类型为银行转账时，银行信息不能为空");
throw new ServiceException(ResultCode.RETURN_MONEY_OFFLINE_BANK_ERROR);
}
}

6
framework/src/main/java/cn/lili/modules/order/order/serviceimpl/OrderComplaintServiceImpl.java
View File

@ -230,7 +230,7 @@ public class OrderComplaintServiceImpl extends ServiceImpl<OrderComplaintMapper,
private OrderComplaint checkOrderComplainExist(String id) {
OrderComplaint orderComplaint = this.getById(id);
if (orderComplaint == null) {
throw new ServiceException("当前投诉记录不存在");
throw new ServiceException(ResultCode.COMPLAINT_NOT_EXIT);
}
return orderComplaint;
}
@ -239,12 +239,12 @@ public class OrderComplaintServiceImpl extends ServiceImpl<OrderComplaintMapper,
ComplaintStatusEnum complaintStatusEnum = ComplaintStatusEnum.valueOf(operationParam.getComplainStatus());
if (complaintStatusEnum == ComplaintStatusEnum.COMPLETE) {
if (StrUtil.isEmpty(operationParam.getArbitrationResult())) {
throw new ServiceException("结束订单投诉时，仲裁结果不能为空");
throw new ServiceException(ResultCode.COMPLAINT_ARBITRATION_RESULT_ERROR);
}
orderComplaint.setArbitrationResult(operationParam.getArbitrationResult());
} else if (complaintStatusEnum == ComplaintStatusEnum.COMMUNICATION) {
if (StrUtil.isEmpty(operationParam.getAppealContent()) || operationParam.getImages() == null) {
throw new ServiceException("商家申诉时，申诉内容不能为空");
throw new ServiceException(ResultCode.COMPLAINT_APPEAL_CONTENT_ERROR);
}
orderComplaint.setContent(operationParam.getAppealContent());
orderComplaint.setImages(operationParam.getImages().get(0));

3
framework/src/main/java/cn/lili/modules/order/order/serviceimpl/OrderItemServiceImpl.java
View File

@ -1,5 +1,6 @@
package cn.lili.modules.order.order.serviceimpl;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.modules.order.order.entity.dos.OrderItem;
import cn.lili.modules.order.order.entity.enums.CommentStatusEnum;
@ -58,7 +59,7 @@ public class OrderItemServiceImpl extends ServiceImpl<OrderItemMapper, OrderItem
queryWrapper.eq(OrderItem::getOrderSn, orderSn).eq(OrderItem::getSkuId, skuId);
OrderItem orderItem = getOne(queryWrapper);
if (orderItem == null) {
throw new ServiceException("当前订单项不存在！");
throw new ServiceException(ResultCode.ORDER_ITEM_NOT_EXIST);
}
orderItem.setComplainId(complainId);
orderItem.setComplainStatus(complainStatusEnum.name());

2
framework/src/main/java/cn/lili/modules/order/order/serviceimpl/OrderServiceImpl.java
View File

@ -544,7 +544,7 @@ public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements
orderBatchDeliverDTOList.add(orderBatchDeliverDTO);
}
} catch (Exception e) {
throw new ServiceException(ResultCode.BATCH_DELIVER_ERROR);
throw new ServiceException(ResultCode.ORDER_BATCH_DELIVER_ERROR);
}
//循环检查是否符合规范
checkBatchDeliver(orderBatchDeliverDTOList);

1
framework/src/main/java/cn/lili/modules/page/entity/vos/ArticleCategoryVO.java
View File

@ -34,6 +34,7 @@ public class ArticleCategoryVO extends ArticleCategory {
children.sort(new Comparator<ArticleCategoryVO>() {
@Override
public int compare(ArticleCategoryVO o1, ArticleCategoryVO o2) {
System.out.println(o1.getArticleCategoryName()+":"+o2.getArticleCategoryName());
return o1.getSort().compareTo(o2.getSort());
}
});

29
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/CouponServiceImpl.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.trigger.util.DelayQueueTools;
import cn.lili.common.trigger.enums.DelayTypeEnums;
import cn.lili.common.trigger.message.PromotionMessage;
@ -130,7 +131,7 @@ public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> impleme
List<CouponVO> couponVOS = this.mongoTemplate.find(query, CouponVO.class);
couponVOS = couponVOS.parallelStream().filter(i -> Boolean.FALSE.equals(i.getDeleteFlag())).collect(Collectors.toList());
if (couponVOS.isEmpty()) {
throw new ServiceException("优惠券不存在");
throw new ServiceException(ResultCode.COUPON_NOT_EXIST);
}
for (CouponVO couponVO : couponVOS) {
if (promotionStatus.name().equals(PromotionStatusEnum.START.name())) {
@ -282,23 +283,21 @@ public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> impleme
private void checkParam(CouponVO coupon) {
if (coupon.getCouponLimitNum() < 0) {
throw new ServiceException("领取限制数量不能为负数");
throw new ServiceException(ResultCode.COUPON_LIMIT_NUM_LESS_THAN_0);
}
//如果发行数量是0则判断领取限制数量
if (coupon.getPublishNum() != 0 && coupon.getCouponLimitNum() > coupon.getPublishNum()) {
throw new ServiceException("领取限制数量超出发行数量");
throw new ServiceException(ResultCode.COUPON_LIMIT_GREATER_THAN_PUBLISH);
}
if (coupon.getCouponType().equals(CouponTypeEnum.PRICE.name()) && coupon.getPrice() > coupon.getConsumeThreshold()) {
throw new ServiceException("优惠券面额必须小于优惠券消费限额");
} else if (coupon.getCouponType().equals(CouponTypeEnum.DISCOUNT.name()) && (coupon.getCouponDiscount() < 0 && coupon.getCouponDiscount() > 10)) {
throw new ServiceException("优惠券折扣必须小于10且大于0");
if (coupon.getCouponType().equals(CouponTypeEnum.DISCOUNT.name()) && (coupon.getCouponDiscount() < 0 && coupon.getCouponDiscount() > 10)) {
throw new ServiceException(ResultCode.COUPON_DISCOUNT_ERROR);
}
if (coupon.getRangeDayType() != null && coupon.getRangeDayType().equals(CouponRangeDayEnum.FIXEDTIME.name())) {
long nowTime = DateUtil.getDateline() * 1000;
if (coupon.getStartTime().getTime() < nowTime && coupon.getEndTime().getTime() > nowTime) {
throw new ServiceException("活动时间小于当前时间，不能进行编辑删除操作");
throw new ServiceException(ResultCode.PROMOTION_TIME_ERROR);
}
PromotionTools.checkPromotionTime(coupon.getStartTime().getTime(), coupon.getEndTime().getTime());
@ -316,24 +315,24 @@ public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> impleme
*/
private void checkCouponScope(CouponVO coupon) {
if (coupon.getScopeType().equals(CouponScopeTypeEnum.PORTION_GOODS.name()) && (coupon.getPromotionGoodsList() == null || coupon.getPromotionGoodsList().isEmpty())) {
throw new ServiceException("当前关联范围类型为指定商品时，商品列表不能为空");
throw new ServiceException(ResultCode.COUPON_SCOPE_TYPE_GOODS_ERROR);
} else if (coupon.getScopeType().equals(CouponScopeTypeEnum.PORTION_GOODS.name()) && CharSequenceUtil.isEmpty(coupon.getScopeId())) {
throw new ServiceException("当前关联范围类型为指定商品时，范围关联的id不能为空");
throw new ServiceException(ResultCode.COUPON_SCOPE_TYPE_GOODS_ERROR);
} else if (coupon.getScopeType().equals(CouponScopeTypeEnum.PORTION_GOODS_CATEGORY.name()) && CharSequenceUtil.isEmpty(coupon.getScopeId())) {
throw new ServiceException("当前关联范围类型为部分商品分类时，范围关联的id不能为空");
throw new ServiceException(ResultCode.COUPON_SCOPE_TYPE_CATEGORY_ERROR);
} else if (coupon.getScopeType().equals(CouponScopeTypeEnum.PORTION_SHOP_CATEGORY.name()) && CharSequenceUtil.isEmpty(coupon.getScopeId())) {
throw new ServiceException("当前关联范围类型为部分店铺分类时，范围关联的id不能为空");
throw new ServiceException(ResultCode.COUPON_SCOPE_TYPE_STORE_ERROR);
}
if (coupon.getScopeType().equals(CouponScopeTypeEnum.PORTION_GOODS.name())) {
String[] split = coupon.getScopeId().split(",");
if (split.length <= 0) {
throw new ServiceException("指定商品范围关联id无效！");
throw new ServiceException(ResultCode.COUPON_SCOPE_ERROR);
}
for (String id : split) {
GoodsSku goodsSku = goodsSkuService.getGoodsSkuByIdFromCache(id);
if (goodsSku == null) {
throw new ServiceException("商品已下架");
throw new ServiceException(ResultCode.GOODS_NOT_EXIST);
}
}
}
@ -375,7 +374,7 @@ public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> impleme
private CouponVO checkStatus(String id) {
CouponVO coupon = this.mongoTemplate.findById(id, CouponVO.class);
if (coupon == null) {
throw new ServiceException("当前优惠券活动不存在");
throw new ServiceException(ResultCode.COUPON_NOT_EXIST);
}
LambdaQueryWrapper<FullDiscount> queryWrapper = new LambdaQueryWrapper<FullDiscount>().eq(FullDiscount::getIsCoupon, true).eq(FullDiscount::getCouponId, id);
FullDiscount fullDiscount = fullDiscountService.getOne(queryWrapper);

20
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/FullDiscountServiceImpl.java
View File

@ -201,7 +201,7 @@ public class FullDiscountServiceImpl extends ServiceImpl<FullDiscountMapper, Ful
private FullDiscountVO checkFullDiscountExist(String id) {
FullDiscountVO fullDiscountVO = mongoTemplate.findById(id, FullDiscountVO.class);
if (fullDiscountVO == null) {
throw new ServiceException("当前要操作的满优惠活动不存在");
throw new ServiceException(ResultCode.FULL_DISCOUNT_NOT_EXIST_ERROR);
}
return fullDiscountVO;
}
@ -213,7 +213,7 @@ public class FullDiscountServiceImpl extends ServiceImpl<FullDiscountMapper, Ful
*/
private void checkFullDiscount(FullDiscountVO fullDiscountVO) {
if (fullDiscountVO.getIsFullMinus() == null && fullDiscountVO.getIsCoupon() == null && fullDiscountVO.getIsGift() == null && fullDiscountVO.getIsPoint() == null && fullDiscountVO.getIsFullRate() == null) {
throw new ServiceException("请选择一种优惠方式");
throw new ServiceException(ResultCode.FULL_DISCOUNT_WAY_ERROR);
}
//如果优惠方式是满减
if (Boolean.TRUE.equals(fullDiscountVO.getIsFullMinus())) {
@ -225,7 +225,7 @@ public class FullDiscountServiceImpl extends ServiceImpl<FullDiscountMapper, Ful
//是否没有选择赠品
boolean noGiftSelected = fullDiscountVO.getGiftId() == null;
if (noGiftSelected) {
throw new ServiceException("请选择赠品");
throw new ServiceException(ResultCode.FULL_DISCOUNT_GIFT_ERROR);
}
}
//如果优惠方式是赠优惠券
@ -253,7 +253,7 @@ public class FullDiscountServiceImpl extends ServiceImpl<FullDiscountMapper, Ful
QueryWrapper<FullDiscount> queryWrapper = PromotionTools.checkActiveTime(statTime, endTime, PromotionTypeEnum.FULL_DISCOUNT, storeId, id);
Integer sameNum = this.count(queryWrapper);
if (sameNum > 0) {
throw new ServiceException("当前时间内已存在同类活动");
throw new ServiceException(ResultCode.PROMOTION_SAME_ACTIVE_EXIST);
}
}
@ -267,11 +267,11 @@ public class FullDiscountServiceImpl extends ServiceImpl<FullDiscountMapper, Ful
//是否没有选择优惠券
boolean noCouponSelected = couponId == null;
if (noCouponSelected) {
throw new ServiceException("请选择优惠券");
throw new ServiceException(ResultCode.COUPON_NOT_EXIST);
}
Coupon coupon = this.couponService.getById(couponId);
if (coupon.getEndTime().getTime() < endTime) {
throw new ServiceException("赠送的优惠券有效时间必须大于活动时间");
throw new ServiceException(ResultCode.FULL_DISCOUNT_COUPON_TIME_ERROR);
}
}
@ -285,10 +285,10 @@ public class FullDiscountServiceImpl extends ServiceImpl<FullDiscountMapper, Ful
//是否没有填写满减金额
boolean noFullMinusInput = fullMinus == null || fullMinus == 0;
if (noFullMinusInput) {
throw new ServiceException("请填写满减金额");
throw new ServiceException(ResultCode.FULL_DISCOUNT_MONEY_ERROR);
}
if (fullMinus > fullMoney) {
throw new ServiceException("满减金额不能大于优惠门槛");
throw new ServiceException(ResultCode.FULL_DISCOUNT_MONEY_GREATER_THAN_MINUS);
}
}
@ -301,11 +301,11 @@ public class FullDiscountServiceImpl extends ServiceImpl<FullDiscountMapper, Ful
//是否没有填写打折数值
boolean noFullRateInput = fullRate == null || fullRate == 0;
if (noFullRateInput) {
throw new ServiceException("请填写打折数值");
throw new ServiceException(ResultCode.FULL_RATE_NUM_ERROR);
}
int rateLimit = 10;
if (fullRate >= rateLimit || fullRate <= 0) {
throw new ServiceException("请填写打折数值");
throw new ServiceException(ResultCode.FULL_RATE_NUM_ERROR);
}
}

4
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/MemberCouponServiceImpl.java
View File

@ -164,7 +164,7 @@ public class MemberCouponServiceImpl extends ServiceImpl<MemberCouponMapper, Mem
public void updateMemberCouponStatus(MemberCouponStatusEnum status, String id) {
MemberCoupon memberCoupon = this.getById(id);
if (memberCoupon == null) {
throw new ServiceException("没有当前会员优惠券！");
throw new ServiceException(ResultCode.COUPON_MEMBER_NOT_EXIST);
}
String memberCouponStatus = memberCoupon.getMemberCouponStatus();
if (memberCouponStatus.equals(MemberCouponStatusEnum.NEW.name()) || memberCouponStatus.equals(MemberCouponStatusEnum.USED.name())) {
@ -172,7 +172,7 @@ public class MemberCouponServiceImpl extends ServiceImpl<MemberCouponMapper, Mem
updateWrapper.eq(MemberCoupon::getId, id).set(MemberCoupon::getMemberCouponStatus, status.name());
this.update(updateWrapper);
} else {
throw new ServiceException("当前会员优惠券已过期/作废无法变更状态！");
throw new ServiceException(ResultCode.COUPON_MEMBER_STATUS_ERROR);
}
}

13
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PintuanServiceImpl.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.bean.BeanUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.trigger.util.DelayQueueTools;
import cn.lili.common.trigger.enums.DelayTypeEnums;
import cn.lili.common.trigger.message.PromotionMessage;
@ -154,7 +155,7 @@ public class PintuanServiceImpl extends ServiceImpl<PintuanMapper, Pintuan> impl
PintuanVO pintuanVO = mongoTemplate.findById(id, PintuanVO.class);
if (pintuanVO == null) {
log.error("拼团活动id[" + id + "]的拼团活动不存在！");
throw new ServiceException("网络出现异常！");
throw new ServiceException(ResultCode.ERROR);
}
return pintuanVO;
}
@ -170,7 +171,7 @@ public class PintuanServiceImpl extends ServiceImpl<PintuanMapper, Pintuan> impl
Pintuan pintuan = this.getById(id);
if (pintuan == null) {
log.error("拼团活动id[" + id + "]的拼团活动不存在！");
throw new ServiceException("网络出现异常！");
throw new ServiceException(ResultCode.ERROR);
}
return pintuan;
}
@ -204,7 +205,7 @@ public class PintuanServiceImpl extends ServiceImpl<PintuanMapper, Pintuan> impl
public boolean modifyPintuan(PintuanVO pintuan) {
PintuanVO pintuanVO = this.checkExist(pintuan.getId());
if (!pintuan.getPromotionStatus().equals(PromotionStatusEnum.NEW.name())) {
throw new ServiceException("只有活动状态为新活动时（活动未开始）才可编辑！");
throw new ServiceException(ResultCode.PINTUAN_EDIT_ERROR);
}
//检查促销时间
PromotionTools.checkPromotionTime(pintuan.getStartTime().getTime(), pintuan.getEndTime().getTime());
@ -358,7 +359,7 @@ public class PintuanServiceImpl extends ServiceImpl<PintuanMapper, Pintuan> impl
memberVO.setOrderSn("");
PromotionGoods promotionGoods = promotionGoodsService.getPromotionGoods(PromotionTypeEnum.PINTUAN, order.getPromotionId(), skuId);
if (promotionGoods == null) {
throw new ServiceException("当前拼团商品不存在！");
throw new ServiceException(ResultCode.PINTUAN_NOT_EXIST_ERROR);
}
pintuanShareVO.setPromotionGoods(promotionGoods);
Pintuan pintuanById = this.getPintuanById(order.getPromotionId());
@ -381,7 +382,7 @@ public class PintuanServiceImpl extends ServiceImpl<PintuanMapper, Pintuan> impl
QueryWrapper<Pintuan> queryWrapper = PromotionTools.checkActiveTime(startTime, endTime, PromotionTypeEnum.PINTUAN, storeId, pintuanId);
List<Pintuan> list = this.list(queryWrapper);
if (!list.isEmpty()) {
throw new ServiceException("当前时间段已存在相同活动！");
throw new ServiceException(ResultCode.PROMOTION_SAME_ERROR);
}
}
@ -484,7 +485,7 @@ public class PintuanServiceImpl extends ServiceImpl<PintuanMapper, Pintuan> impl
private PintuanVO checkExist(String pintuanId) {
PintuanVO pintuan = mongoTemplate.findById(pintuanId, PintuanVO.class);
if (pintuan == null) {
throw new ServiceException("当前拼团活动不存在！");
throw new ServiceException(ResultCode.PINTUAN_NOT_EXIST_ERROR);
}
return pintuan;
}

5
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PointsGoodsServiceImpl.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.util.StrUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.trigger.util.DelayQueueTools;
import cn.lili.common.trigger.enums.DelayTypeEnums;
import cn.lili.common.trigger.message.PromotionMessage;
@ -108,7 +109,7 @@ public class PointsGoodsServiceImpl extends ServiceImpl<PointsGoodsMapper, Point
pointsGoods.setGoodsSku(goodsSku);
if (this.checkSkuDuplicate(pointsGoods.getSkuId(), pointsGoods.getId()) == null) {
if (PromotionStatusEnum.START.name().equals(pointsGoods.getPromotionStatus()) || PromotionStatusEnum.END.name().equals(pointsGoods.getPromotionStatus())) {
throw new ServiceException("当前活动已开始/结束，无法编辑！");
throw new ServiceException(ResultCode.PROMOTION_UPDATE_ERROR);
}
PromotionTools.checkPromotionTime(pointsGoods.getStartTime().getTime(), pointsGoods.getEndTime().getTime());
result = this.updateById(pointsGoods);
@ -304,7 +305,7 @@ public class PointsGoodsServiceImpl extends ServiceImpl<PointsGoodsMapper, Point
*/
private void checkParam(PointsGoods pointsGoods, GoodsSku goodsSku) {
if (pointsGoods.getActiveStock() > goodsSku.getQuantity()) {
throw new ServiceException("活动库存数量不能高于商品库存");
throw new ServiceException(ResultCode.POINT_GOODS_ACTIVE_STOCK_ERROR);
}
}
}

5
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PromotionGoodsServiceImpl.java
View File

@ -2,6 +2,7 @@ package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.BeanUtil;
import cn.lili.common.utils.DateUtil;
@ -270,7 +271,7 @@ public class PromotionGoodsServiceImpl extends ServiceImpl<PromotionGoodsMapper,
PromotionGoods promotionGoods = this.getPromotionGoods(typeEnum, promotionId, skuId);
if (promotionGoods == null) {
throw new ServiceException("当前促销商品不存在！");
throw new ServiceException(ResultCode.PROMOTION_GOODS_NOT_EXIT);
}
if (promotionGoodsStock != null && CharSequenceUtil.isNotEmpty(promotionGoodsStock) && promotionGoods.getQuantity() == Convert.toInt(promotionGoodsStock)) {
return Convert.toInt(promotionGoodsStock);
@ -311,7 +312,7 @@ public class PromotionGoodsServiceImpl extends ServiceImpl<PromotionGoodsMapper,
queryWrapper.eq(SeckillApply::getSeckillId, promotionId).eq(SeckillApply::getSkuId, skuId);
SeckillApply seckillApply = seckillApplyService.getOne(queryWrapper);
if (seckillApply == null) {
throw new ServiceException("当前秒杀活动商品不存在！");
throw new ServiceException(ResultCode.SECKILL_NOT_EXIST_ERROR);
}
LambdaUpdateWrapper<SeckillApply> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(SeckillApply::getSeckillId, promotionId).eq(SeckillApply::getSkuId, skuId);

3
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PromotionServiceImpl.java
View File

@ -3,6 +3,7 @@ package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.trigger.message.PromotionMessage;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.DateUtil;
@ -452,6 +453,6 @@ public class PromotionServiceImpl implements PromotionService {
*/
private void throwPromotionException(PromotionTypeEnum type, String id, String status) {
log.error("当前" + type.name() + "活动ID为[" + id + "] 不存在，更改活动状态至[ " + status + " ]失败！");
throw new ServiceException("当前活动已停止");
throw new ServiceException(ResultCode.PROMOTION_STATUS_END);
}
}

9
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/SeckillServiceImpl.java
View File

@ -1,5 +1,6 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.trigger.util.DelayQueueTools;
import cn.lili.common.trigger.enums.DelayTypeEnums;
import cn.lili.common.trigger.message.PromotionMessage;
@ -153,7 +154,7 @@ public class SeckillServiceImpl extends ServiceImpl<SeckillMapper, Seckill> impl
//检查该秒杀活动是否存在
SeckillVO seckill = checkSeckillExist(seckillVO.getId());
if (PromotionStatusEnum.START.name().equals(seckillVO.getPromotionStatus())) {
throw new ServiceException("活动已经开始，不能进行编辑删除操作");
throw new ServiceException(ResultCode.PROMOTION_UPDATE_ERROR);
}
//检查秒杀活动参数
this.checkSeckillParam(seckillVO, seckillVO.getStoreId());
@ -193,7 +194,7 @@ public class SeckillServiceImpl extends ServiceImpl<SeckillMapper, Seckill> impl
DelayQueueTools.wrapperUniqueKey(DelayTypeEnums.PROMOTION, (PromotionTypeEnum.SECKILL.name() + seckill.getId())),
rocketmqCustomProperties.getPromotionTopic());
} else {
throw new ServiceException("该秒杀活动活动的状态不能删除");
throw new ServiceException(ResultCode.SECKILL_DELETE_ERROR);
}
}
@ -237,7 +238,7 @@ public class SeckillServiceImpl extends ServiceImpl<SeckillMapper, Seckill> impl
rocketmqCustomProperties.getPromotionTopic());
}
} else {
throw new ServiceException("该秒杀活动活动的状态不能关闭");
throw new ServiceException(ResultCode.SECKILL_CLOSE_ERROR);
}
}
@ -279,7 +280,7 @@ public class SeckillServiceImpl extends ServiceImpl<SeckillMapper, Seckill> impl
private SeckillVO checkSeckillExist(String id) {
SeckillVO seckill = this.mongoTemplate.findById(id, SeckillVO.class);
if (seckill == null) {
throw new ServiceException("当前秒杀活动活动不存在");
throw new ServiceException(ResultCode.SECKILL_NOT_EXIST_ERROR);
}
return seckill;
}

7
framework/src/main/java/cn/lili/modules/promotion/tools/PromotionTools.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.promotion.tools;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.DateUtil;
import cn.lili.common.vo.PageVO;
@ -41,7 +42,7 @@ public class PromotionTools {
//如果促销活动选择的是部分商品参加活动
if (num != -1 && goodsList == null) {
throw new ServiceException("请选择要参与活动的商品");
throw new ServiceException(ResultCode.PROMOTION_GOODS_ERROR);
}
}
@ -59,12 +60,12 @@ public class PromotionTools {
//如果活动起始时间小于现在时间
if (startTime < nowTime) {
throw new ServiceException("活动起始时间必须大于当前时间");
throw new ServiceException(ResultCode.PROMOTION_START_TIME_ERROR);
}
//开始时间不能大于结束时间
if (startTime > endTime) {
throw new ServiceException("活动起始时间不能大于活动结束时间");
throw new ServiceException(ResultCode.PROMOTION_TIME_ERROR);
}
}

3
manager-api/src/main/java/cn/lili/controller/other/CustomWordsController.java
View File

@ -1,5 +1,6 @@
package cn.lili.controller.other;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.StringUtils;
import cn.lili.modules.permission.SettingKeys;
@ -49,7 +50,7 @@ public class CustomWordsController {
}
if (!setting.getSettingValue().equals(secretKey)) {
throw new ServiceException("秘钥验证失败！");
throw new ServiceException(ResultCode.CUSTOM_WORDS_SECRET_KEY_ERROR);
}
String res = customWordsService.deploy();

2
manager-api/src/main/java/cn/lili/controller/promotion/CouponManagerController.java
View File

@ -112,7 +112,7 @@ public class CouponManagerController {
private void setStoreInfo(CouponVO couponVO) {
AuthUser currentUser = UserContext.getCurrentUser();
if (currentUser == null) {
throw new ServiceException("获取当前用户信息不存在");
throw new ServiceException(ResultCode.USER_NOT_EXIST);
}
couponVO.setStoreId("platform");
couponVO.setStoreName("platform");