提交 b4b1b71d authored 作者: hzh's avatar hzh

商城模块集成

上级 cc0ff0c8
package org.dromara.mall.api.dto.member;
import lombok.Data;
/**
* 用户收件地址 Response DTO
*
* @author 芋道源码
*/
@Data
public class MemberAddressRespDTO {
/**
* 编号
*/
private Long id;
/**
* 用户编号
*/
private Long userId;
/**
* 收件人名称
*/
private String name;
/**
* 手机号
*/
private String mobile;
/**
* 地区编号
*/
private Integer areaId;
/**
* 收件详细地址
*/
private String detailAddress;
/**
* 是否默认
*/
private Boolean defaultStatus;
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
/**
* 用户信息 Response DTO
*
* @author 芋道源码
*/
@Data
public class MemberConfigRespDTO {
/**
* 积分抵扣开关
*/
private Boolean pointTradeDeductEnable;
/**
* 积分抵扣,单位:分
* <p>
* 1 积分抵扣多少分
*/
private Integer pointTradeDeductUnitPrice;
/**
* 积分抵扣最大值
*/
private Integer pointTradeDeductMaxPrice;
/**
* 1 元赠送多少分
*/
private Integer pointTradeGivePoint;
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
/**
* 会员等级 Resp DTO
*
* @author 芋道源码
*/
@Data
public class MemberLevelRespDTO {
/**
* 编号
*/
private Long id;
/**
* 等级名称
*/
private String name;
/**
* 等级
*/
private Integer level;
/**
* 升级经验
*/
private Integer experience;
/**
* 享受折扣
*/
private Integer discountPercent;
/**
* 状态
*
* 枚举 {@link org.dromara.common.core.enums.CommonStatusEnum}
*/
private Integer status;
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 用户信息 Response DTO
*
* @author 芋道源码
*/
@Data
public class MemberUserRespDTO {
/**
* 用户ID
*/
private Long id;
/**
* 用户昵称
*/
private String nickname;
/**
* 帐号状态
*
* 枚举 {@link org.dromara.common.core.enums.CommonStatusEnum}
*/
private Integer status;
/**
* 用户头像
*/
private String avatar;
/**
* 手机
*/
private String mobile;
/**
* 创建时间(注册时间)
*/
private LocalDateTime createTime;
// ========== 其它信息 ==========
/**
* 会员级别编号
*/
private Long levelId;
/**
* 积分
*/
private Integer point;
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
/**
* OAuth2.0 访问令牌的校验 Response DTO
*
* @author 芋道源码
*/
@Data
public class OAuth2AccessTokenCheckRespDTO implements Serializable {
/**
* 用户编号
*/
private Long userId;
/**
* 用户类型
*/
private Integer userType;
/**
* 用户信息
*/
private Map<String, String> userInfo;
/**
* 租户编号
*/
private Long tenantId;
/**
* 授权范围的数组
*/
private List<String> scopes;
/**
* 过期时间
*/
private LocalDateTime expiresTime;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
/**
* OAuth2.0 访问令牌创建 Request DTO
*
* @author 芋道源码
*/
@Data
public class OAuth2AccessTokenCreateReqDTO implements Serializable {
/**
* 用户编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 用户类型
*/
@NotNull(message = "用户类型不能为空")
// @InEnum(value = UserTypeEnum.class, message = "用户类型必须是 {value}")
private Integer userType;
/**
* 客户端编号
*/
@NotNull(message = "客户端编号不能为空")
private String clientId;
/**
* 授权范围
*/
private List<String> scopes;
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* OAuth2.0 访问令牌的信息 Response DTO
*
* @author 芋道源码
*/
@Data
@Accessors(chain = true)
public class OAuth2AccessTokenRespDTO implements Serializable {
/**
* 访问令牌
*/
private String accessToken;
/**
* 刷新令牌
*/
private String refreshToken;
/**
* 用户编号
*/
private Long userId;
/**
* 用户类型
*/
private Integer userType;
/**
* 过期时间
*/
private LocalDateTime expiresTime;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import org.dromara.common.mall.validation.Mobile;
/**
* 短信验证码的发送 Request DTO
*
* @author 芋道源码
*/
@Data
public class SmsCodeSendReqDTO {
/**
* 手机号
*/
@Mobile
@NotEmpty(message = "手机号不能为空")
private String mobile;
/**
* 发送场景
*/
@NotNull(message = "发送场景不能为空")
// @InEnum(SmsSceneEnum.class)
private Integer scene;
/**
* 发送 IP
*/
@NotEmpty(message = "发送 IP 不能为空")
private String createIp;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import org.dromara.common.mall.validation.Mobile;
/**
* 短信验证码的使用 Request DTO
*
* @author 芋道源码
*/
@Data
public class SmsCodeUseReqDTO {
/**
* 手机号
*/
@Mobile
@NotEmpty(message = "手机号不能为空")
private String mobile;
/**
* 发送场景
*/
@NotNull(message = "发送场景不能为空")
// @InEnum(SmsSceneEnum.class)
private Integer scene;
/**
* 验证码
*/
@NotEmpty(message = "验证码")
private String code;
/**
* 使用 IP
*/
@NotEmpty(message = "使用 IP 不能为空")
private String usedIp;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import org.dromara.common.mall.validation.Mobile;
/**
* 短信验证码的校验 Request DTO
*
* @author 芋道源码
*/
@Data
public class SmsCodeValidateReqDTO {
/**
* 手机号
*/
@Mobile
@NotEmpty(message = "手机号不能为空")
private String mobile;
/**
* 发送场景
*/
@NotNull(message = "发送场景不能为空")
// @InEnum(SmsSceneEnum.class)
private Integer scene;
/**
* 验证码
*/
@NotEmpty(message = "验证码")
private String code;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 取消绑定社交用户 Request DTO
*
* @author 芋道源码
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SocialUserBindReqDTO {
/**
* 用户编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 用户类型
*/
// @InEnum(UserTypeEnum.class)
@NotNull(message = "用户类型不能为空")
private Integer userType;
/**
* 社交平台的类型
*/
// @InEnum(SocialTypeEnum.class)
@NotNull(message = "社交平台的类型不能为空")
private Integer socialType;
/**
* 授权码
*/
@NotEmpty(message = "授权码不能为空")
private String code;
/**
* state
*/
@NotNull(message = "state 不能为空")
private String state;
}
package org.dromara.mall.api.dto.member;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 社交用户 Response DTO
*
* @author 芋道源码
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SocialUserRespDTO {
/**
* 社交用户的 openid
*/
private String openid;
/**
* 社交用户的昵称
*/
private String nickname;
/**
* 社交用户的头像
*/
private String avatar;
/**
* 关联的用户编号
*/
private Long userId;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 社交绑定 Request DTO,使用 code 授权码
*
* @author 芋道源码
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SocialUserUnbindReqDTO {
/**
* 用户编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 用户类型
*/
// @InEnum(UserTypeEnum.class)
@NotNull(message = "用户类型不能为空")
private Integer userType;
/**
* 社交平台的类型
*/
// @InEnum(SocialTypeEnum.class)
@NotNull(message = "社交平台的类型不能为空")
private Integer socialType;
/**
* 社交平台的 openid
*/
@NotEmpty(message = "社交平台的 openid 不能为空")
private String openid;
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
/**
* 微信公众号 JSAPI 签名 Response DTO
*
* @author 芋道源码
*/
@Data
public class SocialWxJsapiSignatureRespDTO {
/**
* 微信公众号的 appId
*/
private String appId;
/**
* 匿名串
*/
private String nonceStr;
/**
* 时间戳
*/
private Long timestamp;
/**
* URL
*/
private String url;
/**
* 签名
*/
private String signature;
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
/**
* 微信小程序的手机信息 Response DTO
*
* @author 芋道源码
*/
@Data
public class SocialWxPhoneNumberInfoRespDTO {
/**
* 用户绑定的手机号(国外手机号会有区号)
*/
private String phoneNumber;
/**
* 没有区号的手机号
*/
private String purePhoneNumber;
/**
* 区号
*/
private String countryCode;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotEmpty;
import lombok.Data;
/**
* 获取小程序码 Request DTO
*
* @author HUIHUI
* @see <a href="https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/qrcode-link/qr-code/getUnlimitedQRCode.html">获取不限制的小程序码</a>
*/
@Data
public class SocialWxQrcodeReqDTO {
/**
* 页面路径不能携带参数(参数请放在scene字段里)
*/
public static final String SCENE = "";
/**
* 二维码宽度
*/
public static final Integer WIDTH = 430;
/**
* 自动配置线条颜色,如果颜色依然是黑色,则说明不建议配置主色调
*/
public static final Boolean AUTO_COLOR = true;
/**
* 检查 page 是否存在
*/
public static final Boolean CHECK_PATH = true;
/**
* 是否需要透明底色
*
* hyaline 为 true 时,生成透明底色的小程序码
*/
public static final Boolean HYALINE = true;
/**
* 场景
*/
@NotEmpty(message = "场景不能为空")
private String scene;
/**
* 页面路径
*/
@NotEmpty(message = "页面路径不能为空")
private String path;
/**
* 二维码宽度
*/
private Integer width;
/**
* 是否需要透明底色
*/
private Boolean autoColor;
/**
* 是否检查 page 是否存在
*/
private Boolean checkPath;
/**
* 是否需要透明底色
*/
private Boolean hyaline;
}
package org.dromara.mall.api.dto.member;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
import java.util.HashMap;
import java.util.Map;
/**
* 微信小程序订阅消息发送 Request DTO
*
* @author HUIHUI
*/
@Data
@Accessors(chain = true)
public class SocialWxaSubscribeMessageSendReqDTO {
/**
* 用户编号
*
* 关联 MemberUserDO 的 id 编号
* 关联 AdminUserDO 的 id 编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 用户类型
*
* 关联 {@link org.dromara.common.mall.enums.UserTypeEnum}
*/
@NotNull(message = "用户类型不能为空")
private Integer userType;
/**
* 消息模版标题
*/
@NotEmpty(message = "消息模版标题不能为空")
private String templateTitle;
/**
* 点击模板卡片后的跳转页面,仅限本小程序内的页面
*
* 支持带参数,(示例 index?foo=bar )。该字段不填则模板无跳转。
*/
private String page;
/**
* 模板内容的参数
*/
private Map<String, String> messages;
public SocialWxaSubscribeMessageSendReqDTO addMessage(String key, String value) {
if (messages == null) {
messages = new HashMap<>();
}
messages.put(key, value);
return this;
}
}
package org.dromara.mall.api.dto.member;
import lombok.Data;
/**
* 小程序订阅消息模版 Response DTO
*
* @author HUIHUI
*/
@Data
public class SocialWxaSubscribeTemplateRespDTO {
/**
* 模版编号
*/
private String id;
/**
* 模版标题
*/
private String title;
/**
* 模版内容
*/
private String content;
/**
* 模板内容示例
*/
private String example;
/**
* 模版类型
*
* 2:为一次性订阅
* 3:为长期订阅
*/
private Integer type;
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.DecimalMin;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Length;
import java.io.Serializable;
import java.time.LocalDateTime;
/**
* 支付单创建 Request DTO
*/
@Data
@Accessors(chain = true)
public class PayOrderCreateReqDTO implements Serializable {
public static final int SUBJECT_MAX_LENGTH = 32;
/**
* 应用标识
*/
@NotNull(message = "应用标识不能为空")
private String appKey;
/**
* 用户 IP
*/
@NotEmpty(message = "用户 IP 不能为空")
private String userIp;
// ========== 商户相关字段 ==========
/**
* 商户订单编号
*/
@NotEmpty(message = "商户订单编号不能为空")
private String merchantOrderId;
/**
* 商品标题
*/
@NotEmpty(message = "商品标题不能为空")
@Length(max = SUBJECT_MAX_LENGTH, message = "商品标题不能超过 32")
private String subject;
/**
* 商品描述
*/
@Length(max = 128, message = "商品描述信息长度不能超过128")
private String body;
// ========== 订单相关字段 ==========
/**
* 支付金额,单位:分
*/
@NotNull(message = "支付金额不能为空")
@DecimalMin(value = "0", inclusive = false, message = "支付金额必须大于零")
private Integer price;
/**
* 支付过期时间
*/
@NotNull(message = "支付过期时间不能为空")
private LocalDateTime expireTime;
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 支付单的通知 Request DTO
*
* @author 芋道源码
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PayOrderNotifyReqDTO {
/**
* 商户订单编号
*/
@NotEmpty(message = "商户订单号不能为空")
private String merchantOrderId;
/**
* 支付订单编号
*/
@NotNull(message = "支付订单编号不能为空")
private Long payOrderId;
}
package org.dromara.mall.api.dto.pay;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 支付单信息 Response DTO
*
* @author 芋道源码
*/
@Data
public class PayOrderRespDTO {
/**
* 订单编号,数据库自增
*/
private Long id;
/**
* 渠道编码
*
* 枚举 PayChannelEnum
*/
private String channelCode;
// ========== 商户相关字段 ==========
/**
* 商户订单编号
* 例如说,内部系统 A 的订单号。需要保证每个 PayMerchantDO 唯一
*/
private String merchantOrderId;
// ========== 订单相关字段 ==========
/**
* 支付金额,单位:分
*/
private Integer price;
/**
* 支付状态
*
* 枚举 {@link org.dromara.mall.enums.pay.order.PayOrderStatusEnum}
*/
private Integer status;
/**
* 订单支付成功时间
*/
private LocalDateTime successTime;
// ========== 渠道相关字段 ==========
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.DecimalMin;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.URL;
import java.time.LocalDateTime;
import java.util.Map;
/**
* 统一下单 Request DTO
*
* @author 芋道源码
*/
@Data
@Accessors(chain = true)
public class PayOrderUnifiedReqDTO {
/**
* 用户 IP
*/
@NotEmpty(message = "用户 IP 不能为空")
private String userIp;
// ========== 商户相关字段 ==========
/**
* 外部订单号
*
* 对应 PayOrderExtensionDO 的 no 字段
*/
@NotEmpty(message = "外部订单编号不能为空")
private String outTradeNo;
/**
* 商品标题
*/
@NotEmpty(message = "商品标题不能为空")
@Length(max = 32, message = "商品标题不能超过 32")
private String subject;
/**
* 商品描述信息
*/
@Length(max = 128, message = "商品描述信息长度不能超过128")
private String body;
/**
* 支付结果的 notify 回调地址
*/
@NotEmpty(message = "支付结果的回调地址不能为空")
@URL(message = "支付结果的 notify 回调地址必须是 URL 格式")
private String notifyUrl;
/**
* 支付结果的 return 回调地址
*/
@URL(message = "支付结果的 return 回调地址必须是 URL 格式")
private String returnUrl;
// ========== 订单相关字段 ==========
/**
* 支付金额,单位:分
*/
@NotNull(message = "支付金额不能为空")
@DecimalMin(value = "0", inclusive = false, message = "支付金额必须大于零")
private Integer price;
/**
* 支付过期时间
*/
@NotNull(message = "支付过期时间不能为空")
private LocalDateTime expireTime;
// ========== 拓展参数 ==========
/**
* 支付渠道的额外参数
*
* 例如说,微信公众号需要传递 openid 参数
*/
private Map<String, String> channelExtras;
/**
* 展示模式
*
* 如果不传递,则每个支付渠道使用默认的方式
*
* 枚举 {@link org.dromara.common.pay.core.enums.order.PayOrderDisplayModeEnum}
*/
private String displayMode;
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Length;
/**
* 退款单创建 Request DTO
*
* @author 芋道源码
*/
@Data
@Accessors(chain = true)
public class PayRefundCreateReqDTO {
/**
* 应用标识
*/
@NotNull(message = "应用标识不能为空")
private String appKey;
/**
* 用户 IP
*/
@NotEmpty(message = "用户 IP 不能为空")
private String userIp;
// ========== 商户相关字段 ==========
/**
* 商户订单编号
*/
@NotEmpty(message = "商户订单编号不能为空")
private String merchantOrderId;
/**
* 商户退款编号
*/
@NotEmpty(message = "商户退款编号不能为空")
private String merchantRefundId;
/**
* 退款描述
*/
@NotEmpty(message = "退款描述不能为空")
@Length(max = 128, message = "退款描述长度不能超过 128")
private String reason;
// ========== 订单相关字段 ==========
/**
* 退款金额,单位:分
*/
@NotNull(message = "退款金额不能为空")
@Min(value = 1, message = "退款金额必须大于零")
private Integer price;
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 退款单的通知 Request DTO
*
* @author 芋道源码
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PayRefundNotifyReqDTO {
/**
* 商户退款单编号
*/
@NotEmpty(message = "商户退款单编号不能为空")
private String merchantOrderId;
/**
* 支付退款编号
*/
@NotNull(message = "支付退款编号不能为空")
private Long payRefundId;
}
package org.dromara.mall.api.dto.pay;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 退款单信息 Response DTO
*
* @author 芋道源码
*/
@Data
public class PayRefundRespDTO {
/**
* 退款单编号
*/
private Long id;
/**
* 渠道编码
*
* 枚举 PayChannelEnum
*/
private String channelCode;
// ========== 退款相关字段 ==========
/**
* 退款状态
*
* 枚举 {@link org.dromara.mall.enums.pay.refund.PayRefundStatusEnum}
*/
private Integer status;
/**
* 退款金额,单位:分
*/
private Integer refundPrice;
// ========== 商户相关字段 ==========
/**
* 商户订单编号
*/
private String merchantOrderId;
/**
* 退款成功时间
*/
private LocalDateTime successTime;
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
import org.dromara.common.mall.validation.InEnum;
import org.dromara.mall.enums.pay.transfer.PayTransferTypeEnum;
import java.util.Map;
/**
* 转账单创建 Request DTO
*
* @author jason
*/
@Data
@Accessors(chain = true)
public class PayTransferCreateReqDTO {
/**
* 应用标识
*/
@NotNull(message = "应用标识不能为空")
private String appKey;
@NotEmpty(message = "转账渠道不能为空")
private String channelCode;
/**
* 转账渠道的额外参数
*/
private Map<String, String> channelExtras;
@NotEmpty(message = "用户 IP 不能为空")
private String userIp;
/**
* 类型
*/
@NotNull(message = "转账类型不能为空")
@InEnum(PayTransferTypeEnum.class)
private Integer type;
/**
* 商户转账单编号
*/
@NotEmpty(message = "商户转账单编号能为空")
private String merchantTransferId;
/**
* 转账金额,单位:分
*/
@Min(value = 1, message = "转账金额必须大于零")
@NotNull(message = "转账金额不能为空")
private Integer price;
/**
* 转账标题
*/
@NotEmpty(message = "转账标题不能为空")
private String subject;
/**
* 收款人姓名
*/
@NotBlank(message = "收款人姓名不能为空", groups = {PayTransferTypeEnum.Alipay.class})
private String userName;
@NotBlank(message = "支付宝登录号不能为空", groups = {PayTransferTypeEnum.Alipay.class})
private String alipayLogonId;
// ========== 微信转账相关字段 ==========
@NotBlank(message = "微信 openId 不能为空", groups = {PayTransferTypeEnum.WxPay.class})
private String openid;
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 转账单的通知 Request DTO
*
* @author jason
*/
@Data
@Accessors(chain = true)
public class PayTransferNotifyReqDTO {
// TODO 芋艿:要不要改成 orderId 待定;
/**
* 商户转账单号
*/
@NotEmpty(message = "商户转账单号不能为空")
private String merchantTransferId;
/**
* 转账订单编号
*/
@NotNull(message = "转账订单编号不能为空")
private Long payTransferId;
}
package org.dromara.mall.api.dto.pay;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 钱包余额增加 Request DTO
*
* @author 芋道源码
*/
@Data
@Accessors(chain = true)
public class PayWalletAddBalanceReqDTO {
/**
* 用户编号
*
* 关联 MemberUserDO 的 id 属性,或者 AdminUserDO 的 id 属性
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 用户类型
*
* 关联 {@link org.dromara.common.mall.enums.UserTypeEnum}
*/
@NotNull(message = "用户类型不能为空")
private Integer userType;
/**
* 关联业务分类
*/
@NotNull(message = "关联业务分类不能为空")
private Integer bizType;
/**
* 关联业务编号
*/
@NotNull(message = "关联业务编号不能为空")
private String bizId;
/**
* 交易金额,单位分
*
* 正值表示余额增加,负值表示余额减少
*/
@NotNull(message = "交易金额不能为空")
private Integer price;
}
package org.dromara.mall.api.dto.product;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.util.List;
/**
* 评论创建请求 DTO
*
* @author HUIHUI
*/
@Data
public class ProductCommentCreateReqDTO {
/**
* 商品 SKU 编号
*/
@NotNull(message = "商品 SKU 编号不能为空")
private Long skuId;
/**
* 订单编号
*/
private Long orderId;
/**
* 交易订单项编号
*/
private Long orderItemId;
/**
* 描述星级 1-5 分
*/
@NotNull(message = "描述星级不能为空")
private Integer descriptionScores;
/**
* 服务星级 1-5 分
*/
@NotNull(message = "服务星级不能为空")
private Integer benefitScores;
/**
* 评论内容
*/
@NotNull(message = "评论内容不能为空")
private String content;
/**
* 评论图片地址数组,以逗号分隔最多上传 9 张
*/
private List<String> picUrls;
/**
* 是否匿名
*/
@NotNull(message = "是否匿名不能为空")
private Boolean anonymous;
/**
* 评价人
*/
@NotNull(message = "评价人不能为空")
private Long userId;
}
package org.dromara.mall.api.dto.product;
import lombok.Data;
/**
* 商品属性项的明细 Response DTO
*
* @author 芋道源码
*/
@Data
public class ProductPropertyValueDetailRespDTO {
/**
* 属性的编号
*/
private Long propertyId;
/**
* 属性的名称
*/
private String propertyName;
/**
* 属性值的编号
*/
private Long valueId;
/**
* 属性值的名称
*/
private String valueName;
}
package org.dromara.mall.api.dto.product;
import lombok.Data;
import java.util.List;
/**
* 商品 SKU 信息 Response DTO
*
* @author LeeYan9
* @since 2022-08-26
*/
@Data
public class ProductSkuRespDTO {
/**
* 商品 SKU 编号,自增
*/
private Long id;
/**
* SPU 编号
*/
private Long spuId;
/**
* 属性数组
*/
private List<ProductPropertyValueDetailRespDTO> properties;
/**
* 销售价格,单位:分
*/
private Integer price;
/**
* 市场价,单位:分
*/
private Integer marketPrice;
/**
* 成本价,单位:分
*/
private Integer costPrice;
/**
* SKU 的条形码
*/
private String barCode;
/**
* 图片地址
*/
private String picUrl;
/**
* 库存
*/
private Integer stock;
/**
* 商品重量,单位:kg 千克
*/
private Double weight;
/**
* 商品体积,单位:m^3 平米
*/
private Double volume;
/**
* 一级分销的佣金,单位:分
*/
private Integer firstBrokeragePrice;
/**
* 二级分销的佣金,单位:分
*/
private Integer secondBrokeragePrice;
}
package org.dromara.mall.api.dto.product;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.List;
/**
* 商品 SKU 更新库存 Request DTO
*
* @author LeeYan9
* @since 2022-08-26
*/
@Data
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
public class ProductSkuUpdateStockReqDTO {
/**
* 商品 SKU
*/
@NotNull(message = "商品 SKU 不能为空")
private List<Item> items;
@Data
@Accessors(chain = true)
public static class Item {
/**
* 商品 SKU 编号
*/
@NotNull(message = "商品 SKU 编号不能为空")
private Long id;
/**
* 库存变化数量
*
* 正数:增加库存
* 负数:扣减库存
*/
@NotNull(message = "库存变化数量不能为空")
private Integer incrCount;
}
}
package org.dromara.mall.api.dto.product;
import lombok.Data;
import java.util.List;
/**
* 商品 SPU 信息 Response DTO
*
* @author LeeYan9
* @since 2022-08-26
*/
@Data
public class ProductSpuRespDTO {
/**
* 商品 SPU 编号,自增
*/
private Long id;
// ========== 基本信息 =========
/**
* 商品名称
*/
private String name;
/**
* 商品分类编号
*/
private Long categoryId;
/**
* 商品封面图
*/
private String picUrl;
/**
* 商品状态
* <p>
* 枚举 {@link org.dromara.mall.enums.product.spu.ProductSpuStatusEnum}
*/
private Integer status;
// ========== SKU 相关字段 =========
/**
* 规格类型
*
* false - 单规格
* true - 多规格
*/
private Boolean specType;
/**
* 商品价格,单位使用:分
*/
private Integer price;
/**
* 市场价,单位使用:分
*/
private Integer marketPrice;
/**
* 成本价,单位使用:分
*/
private Integer costPrice;
/**
* 库存
*/
private Integer stock;
// ========== 物流相关字段 =========
/**
* 配送方式数组
*
* 对应 DeliveryTypeEnum 枚举
*/
private List<Integer> deliveryTypes;
/**
* 物流配置模板编号
*
* 对应 TradeDeliveryExpressTemplateDO 的 id 编号
*/
private Long deliveryTemplateId;
// ========== 营销相关字段 =========
/**
* 赠送积分
*/
private Integer giveIntegral;
// ========== 分销相关字段 =========
/**
* 分销类型
*
* false - 默认
* true - 自行设置
*/
private Boolean subCommissionType;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 校验参与砍价 Response DTO
*/
@Data
@Accessors(chain = true)
public class BargainValidateJoinRespDTO {
/**
* 砍价活动编号
*/
private Long activityId;
/**
* 砍价活动名称
*/
private String name;
/**
* 砍价金额
*/
private Integer bargainPrice;
}
package org.dromara.mall.api.dto.promotion;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
/**
* 拼团记录的创建 Request DTO
*
* @author HUIHUI
*/
@Data
public class CombinationRecordCreateReqDTO {
/**
* 拼团活动编号
*/
@NotNull(message = "拼团活动编号不能为空")
private Long activityId;
/**
* spu 编号
*/
@NotNull(message = "spu 编号不能为空")
private Long spuId;
/**
* sku 编号
*/
@NotNull(message = "sku 编号不能为空")
private Long skuId;
/**
* 购买的商品数量
*/
@NotNull(message = "购买数量不能为空")
private Integer count;
/**
* 订单编号
*/
@NotNull(message = "订单编号不能为空")
private Long orderId;
/**
* 用户编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 团长编号
*/
private Long headId;
/**
* 拼团商品单价
*/
@NotNull(message = "拼团商品单价不能为空")
private Integer combinationPrice;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 拼团记录的创建 Response DTO
*
* @author HUIHUI
*/
@Data
@Accessors(chain = true)
public class CombinationRecordCreateRespDTO {
/**
* 拼团活动编号
*
* 关联 CombinationActivityDO 的 id 字段
*/
private Long combinationActivityId;
/**
* 拼团团长编号
*
* 关联 CombinationRecordDO 的 headId 字段
*/
private Long combinationHeadId;
/**
* 拼团记录编号
*
* 关联 CombinationRecordDO 的 id 字段
*/
private Long combinationRecordId;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 拼团记录 Response DTO
*
* @author 芋道源码
*/
@Data
public class CombinationRecordRespDTO {
/**
* 编号,主键自增
*/
private Long id;
/**
* 拼团活动编号
*
* 关联 CombinationActivityDO 的 id 字段
*/
private Long activityId;
/**
* 拼团商品单价
*
* 冗余 CombinationProductDO 的 combinationPrice 字段
*/
private Integer combinationPrice;
/**
* SPU 编号
*/
private Long spuId;
/**
* 商品名字
*/
private String spuName;
/**
* 商品图片
*/
private String picUrl;
/**
* SKU 编号
*/
private Long skuId;
/**
* 购买的商品数量
*/
private Integer count;
/**
* 用户编号
*/
private Long userId;
/**
* 用户昵称
*/
private String nickname;
/**
* 用户头像
*/
private String avatar;
/**
* 团长编号
*/
private Long headId;
/**
* 开团状态
*
* 关联 {@link CombinationRecordStatusEnum}
*/
private Integer status;
/**
* 订单编号
*/
private Long orderId;
/**
* 开团需要人数
*
* 关联 CombinationActivityDO 的 userSize 字段
*/
private Integer userSize;
/**
* 已加入拼团人数
*/
private Integer userCount;
/**
* 是否虚拟成团
*/
private Boolean virtualGroup;
/**
* 过期时间
*/
private LocalDateTime expireTime;
/**
* 开始时间 (订单付款后开始的时间)
*/
private LocalDateTime startTime;
/**
* 结束时间(成团时间/失败时间)
*/
private LocalDateTime endTime;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 校验参与拼团 Response DTO
*
* @author HUIHUI
*/
@Data
@Accessors(chain = true)
public class CombinationValidateJoinRespDTO {
/**
* 砍价活动编号
*/
private Long activityId;
/**
* 砍价活动名称
*/
private String name;
/**
* 拼团金额
*/
private Integer combinationPrice;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
import org.dromara.mall.enums.promotion.common.PromotionDiscountTypeEnum;
import org.dromara.mall.enums.promotion.coupon.CouponStatusEnum;
import org.dromara.mall.enums.promotion.coupon.CouponTakeTypeEnum;
import java.time.LocalDateTime;
import java.util.List;
/**
* 优惠劵 Response DTO
*
* @author 芋道源码
*/
@Data
public class CouponRespDTO {
// ========== 基本信息 BEGIN ==========
/**
* 优惠劵编号
*/
private Long id;
/**
* 优惠劵模板编号
*/
private Integer templateId;
/**
* 优惠劵名
*/
private String name;
/**
* 优惠码状态
* <p>
* 枚举 {@link CouponStatusEnum}
*/
private Integer status;
// ========== 基本信息 END ==========
// ========== 领取情况 BEGIN ==========
/**
* 用户编号
* <p>
* 关联 MemberUserDO 的 id 字段
*/
private Long userId;
/**
* 领取类型
* <p>
* 枚举 {@link CouponTakeTypeEnum}
*/
private Integer takeType;
// ========== 领取情况 END ==========
// ========== 使用规则 BEGIN ==========
/**
* 是否设置满多少金额可用,单位:分
*/
private Integer usePrice;
/**
* 生效开始时间
*/
private LocalDateTime validStartTime;
/**
* 生效结束时间
*/
private LocalDateTime validEndTime;
/**
* 商品范围
*/
private Integer productScope;
/**
* 商品范围编号的数组
*/
private List<Long> productScopeValues;
// ========== 使用规则 END ==========
// ========== 使用效果 BEGIN ==========
/**
* 折扣类型
*/
private Integer discountType;
/**
* 折扣百分比
*/
private Integer discountPercent;
/**
* 优惠金额,单位:分
*/
private Integer discountPrice;
/**
* 折扣上限,仅在 {@link #discountType} 等于 {@link PromotionDiscountTypeEnum#PERCENT} 时生效
*/
private Integer discountLimitPrice;
// ========== 使用效果 END ==========
// ========== 使用情况 BEGIN ==========
/**
* 使用订单号
*/
private Long useOrderId;
/**
* 使用时间
*/
private LocalDateTime useTime;
// ========== 使用情况 END ==========
}
package org.dromara.mall.api.dto.promotion;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 优惠劵使用 Request DTO
*
* @author 芋道源码
*/
@Data
@Accessors(chain = true)
public class CouponUseReqDTO {
/**
* 优惠劵编号
*/
@NotNull(message = "优惠劵编号不能为空")
private Long id;
/**
* 用户编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 订单编号
*/
@NotNull(message = "订单编号不能为空")
private Long orderId;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 限时折扣活动商品 Response DTO
*
* @author 芋道源码
*/
@Data
public class DiscountProductRespDTO {
/**
* 编号,主键自增
*/
private Long id;
/**
* 商品 SPU 编号
*/
private Long spuId;
/**
* 商品 SKU 编号
*/
private Long skuId;
/**
* 折扣类型
*/
private Integer discountType;
/**
* 折扣百分比
*/
private Integer discountPercent;
/**
* 优惠金额,单位:分
*/
private Integer discountPrice;
// ========== 活动字段 ==========
/**
* 限时折扣活动的编号
*/
private Long activityId;
/**
* 活动标题
*/
private String activityName;
/**
* 活动开始时间点
*/
private LocalDateTime activityStartTime;
/**
* 活动结束时间点
*/
private LocalDateTime activityEndTime;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
/**
* 校验参与积分商城 Response DTO
*/
@Data
public class PointValidateJoinRespDTO {
/**
* 可兑换次数
*/
private Integer count;
/**
* 所需兑换积分
*/
private Integer point;
/**
* 所需兑换金额,单位:分
*/
private Integer price;
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
import lombok.experimental.Accessors;
import org.dromara.common.mall.enums.CommonStatusEnum;
import org.dromara.mall.enums.promotion.common.PromotionConditionTypeEnum;
import org.dromara.mall.enums.promotion.common.PromotionProductScopeEnum;
import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
/**
* 满减送活动的匹配 Response DTO
*
* @author 芋道源码
*/
@Data
public class RewardActivityMatchRespDTO {
/**
* 匹配的 SPU 数组
*/
private List<Long> spuIds;
/**
* 活动编号,主键自增
*/
private Long id;
/**
* 活动标题
*/
private String name;
/**
* 状态
*
* 枚举 {@link CommonStatusEnum}
*/
private Integer status;
/**
* 开始时间
*/
private LocalDateTime startTime;
/**
* 结束时间
*/
private LocalDateTime endTime;
/**
* 备注
*/
private String remark;
/**
* 条件类型
*
* 枚举 {@link PromotionConditionTypeEnum}
*/
private Integer conditionType;
/**
* 商品范围
*
* 枚举 {@link PromotionProductScopeEnum}
*/
private Integer productScope;
/**
* 商品 SPU 编号的数组
*/
private List<Long> productScopeValues;
/**
* 优惠规则的数组
*/
private List<Rule> rules;
/**
* 优惠规则
*/
@Data
@Accessors(chain = true)
public static class Rule implements Serializable {
/**
* 优惠门槛
*
* 1. 满 N 元,单位:分
* 2. 满 N 件
*/
private Integer limit;
/**
* 优惠价格,单位:分
*/
private Integer discountPrice;
/**
* 是否包邮
*/
private Boolean freeDelivery;
/**
* 赠送的积分
*/
private Integer point;
/**
* 赠送的优惠劵
*
* key: 优惠劵模版编号
* value:对应的优惠券数量
*
* 目的:用于订单支付后赠送优惠券
*/
private Map<Long, Integer> giveCouponTemplateCounts;
/**
* 规则描述
*
* 通过 {@link #limit}、{@link #discountPrice} 等字段进行拼接
*/
private String description;
}
}
package org.dromara.mall.api.dto.promotion;
import lombok.Data;
/**
* 校验参与秒杀 Response DTO
*/
@Data
public class SeckillValidateJoinRespDTO {
/**
* 秒杀活动名称
*/
private String name;
/**
* 总限购数量
*
* 目的:目前只有 trade 有具体下单的数据,需要交给 trade 价格计算使用
*/
private Integer totalLimitCount;
/**
* 秒杀金额
*/
private Integer seckillPrice;
}
package org.dromara.mall.api.dto.system;
import lombok.Data;
import java.util.Set;
/**
* Admin 用户 Response DTO
*
* @author 芋道源码
*/
@Data
public class AdminUserRespDTO {
/**
* 用户ID
*/
private Long id;
/**
* 用户昵称
*/
private String nickname;
/**
* 帐号状态
*
* 枚举 {@link CommonStatusEnum}
*/
private Integer status;
/**
* 部门ID
*/
private Long deptId;
/**
* 岗位编号数组
*/
private Set<Long> postIds;
/**
* 手机号码
*/
private String mobile;
/**
* 用户头像
*/
private String avatar;
}
package org.dromara.mall.api.dto.system;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
import java.util.Map;
/**
* 站内信发送给 Admin 或者 Member 用户
*
* @author xrcoder
*/
@Data
@Accessors(chain = true)
public class NotifySendSingleToUserReqDTO {
/**
* 用户编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
/**
* 站内信模板编号
*/
@NotEmpty(message = "站内信模板编号不能为空")
private String templateCode;
/**
* 站内信模板参数
*/
private Map<String, Object> templateParams;
}
package org.dromara.mall.api.dto.system;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import org.dromara.common.mall.enums.CommonStatusEnum;
import org.dromara.common.mall.validation.InEnum;
@Data
public class NotifyTemplateReqDTO {
@NotEmpty(message = "模版名称不能为空")
private String name;
@NotNull(message = "模版编码不能为空")
private String code;
@NotNull(message = "模版类型不能为空")
private Integer type;
@NotEmpty(message = "发送人名称不能为空")
private String nickname;
@NotEmpty(message = "模版内容不能为空")
private String content;
@NotNull(message = "状态不能为空")
@InEnum(value = CommonStatusEnum.class, message = "状态必须是 {value}")
private Integer status;
private String remark;
}
package org.dromara.mall.api.dto.system;
import lombok.Data;
/**
* 微信公众号 JSAPI 签名 Response DTO
*
* @author 芋道源码
*/
@Data
public class SocialWxJsapiSignatureRespDTO {
/**
* 微信公众号的 appId
*/
private String appId;
/**
* 匿名串
*/
private String nonceStr;
/**
* 时间戳
*/
private Long timestamp;
/**
* URL
*/
private String url;
/**
* 签名
*/
private String signature;
}
package org.dromara.mall.api.dto.trade;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 订单信息 Response DTO
*
* @author HUIHUI
*/
@Data
public class TradeOrderRespDTO {
// ========== 订单基本信息 ==========
/**
* 订单编号,主键自增
*/
private Long id;
/**
* 订单流水号
*
* 例如说,1146347329394184195
*/
private String no;
/**
* 订单类型
*
* 枚举 {@link TradeOrderTypeEnum}
*/
private Integer type;
/**
* 订单来源
*
* 枚举 {@link TerminalEnum}
*/
private Integer terminal;
/**
* 用户编号
*/
private Long userId;
/**
* 用户 IP
*/
private String userIp;
/**
* 用户备注
*/
private String userRemark;
/**
* 订单状态
*
* 枚举 {@link TradeOrderStatusEnum}
*/
private Integer status;
/**
* 购买的商品数量
*/
private Integer productCount;
/**
* 订单完成时间
*/
private LocalDateTime finishTime;
/**
* 订单取消时间
*/
private LocalDateTime cancelTime;
/**
* 取消类型
*
* 枚举 {@link TradeOrderCancelTypeEnum}
*/
private Integer cancelType;
/**
* 商家备注
*/
private String remark;
/**
* 是否评价
*/
private Boolean commentStatus;
// ========== 价格 + 支付基本信息 ==========
/**
* 支付订单编号
*/
private Long payOrderId;
/**
* 是否已支付
*/
private Boolean payStatus;
}
package org.dromara.mall.api.message.user;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 会员用户创建消息
*
* @author owen
*/
@Data
@Accessors(chain = true)
public class MemberUserCreateMessage {
/**
* 用户编号
*/
@NotNull(message = "用户编号不能为空")
private Long userId;
}
package org.dromara.mall.api.service.infra;
import org.dromara.common.core.utils.json.JsonUtils;
/**
* WebSocket 发送器的 API 接口
*
* 对 WebSocketMessageSender 进行封装,提供给其它模块使用
*
* @author 芋道源码
*/
public interface WebSocketSenderApi {
/**
* 发送消息给指定用户
*
* @param userType 用户类型
* @param userId 用户编号
* @param messageType 消息类型
* @param messageContent 消息内容,JSON 格式
*/
void send(Integer userType, Long userId, String messageType, String messageContent);
/**
* 发送消息给指定用户类型
*
* @param userType 用户类型
* @param messageType 消息类型
* @param messageContent 消息内容,JSON 格式
*/
void send(Integer userType, String messageType, String messageContent);
/**
* 发送消息给指定 Session
*
* @param sessionId Session 编号
* @param messageType 消息类型
* @param messageContent 消息内容,JSON 格式
*/
void send(String sessionId, String messageType, String messageContent);
default void sendObject(Integer userType, Long userId, String messageType, Object messageContent) {
send(userType, userId, messageType, JsonUtils.toJsonString(messageContent));
}
default void sendObject(Integer userType, String messageType, Object messageContent) {
send(userType, messageType, JsonUtils.toJsonString(messageContent));
}
default void sendObject(String sessionId, String messageType, Object messageContent) {
send(sessionId, messageType, JsonUtils.toJsonString(messageContent));
}
}
package org.dromara.mall.api.service.infra.impl;
import org.dromara.common.websocket.dto.WebSocketMessageDto;
import org.dromara.common.websocket.utils.WebSocketUtils;
import org.dromara.mall.api.service.infra.WebSocketSenderApi;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* WebSocket 发送器的 API 实现类
*
* @author 芋道源码
*/
@Component
public class WebSocketSenderApiImpl implements WebSocketSenderApi {
@Override
public void send(Integer userType, Long userId, String messageType, String messageContent) {
WebSocketMessageDto dto = new WebSocketMessageDto();
dto.setSessionKeys(List.of(userId));
dto.setMessage(messageContent);
WebSocketUtils.publishMessage(dto);
}
@Override
public void send(Integer userType, String messageType, String messageContent) {
WebSocketMessageDto dto = new WebSocketMessageDto();
//TODO WHO根据用户类型查询用户id集合
dto.setSessionKeys(List.of(userType.longValue()));
dto.setMessage(messageContent);
WebSocketUtils.publishMessage(dto);
}
@Override
public void send(String sessionId, String messageType, String messageContent) {
WebSocketMessageDto dto = new WebSocketMessageDto();
dto.setSessionKeys(List.of(Long.valueOf(sessionId)));
dto.setMessage(messageContent);
WebSocketUtils.publishMessage(dto);
}
}
package org.dromara.mall.api.service.member;
import org.dromara.mall.api.dto.member.MemberAddressRespDTO;
/**
* 用户收件地址 API 接口
*
* @author 芋道源码
*/
public interface MemberAddressApi {
/**
* 获得用户收件地址
*
* @param id 收件地址编号
* @param userId 用户编号
* @return 用户收件地址
*/
MemberAddressRespDTO getAddress(Long id, Long userId);
/**
* 获得用户默认收件地址
*
* @param userId 用户编号
* @return 用户收件地址
*/
MemberAddressRespDTO getDefaultAddress(Long userId);
}
package org.dromara.mall.api.service.member;
import org.dromara.mall.api.dto.member.MemberConfigRespDTO;
/**
* 用户配置 API 接口
*
* @author owen
*/
public interface MemberConfigApi {
/**
* 获得积分配置
*
* @return 积分配置
*/
MemberConfigRespDTO getConfig();
}
package org.dromara.mall.api.service.member;
import org.dromara.mall.api.dto.member.MemberLevelRespDTO;
/**
* 会员等级 API 接口
*
* @author owen
*/
public interface MemberLevelApi {
/**
* 获得会员等级
*
* @param id 会员等级编号
* @return 会员等级
*/
MemberLevelRespDTO getMemberLevel(Long id);
/**
* 增加会员经验
*
* @param userId 会员ID
* @param experience 经验
* @param bizType 业务类型 {@link org.dromara.mall.enums.member.experience.MemberExperienceBizTypeEnum}
* @param bizId 业务编号
*/
void addExperience(Long userId, Integer experience, Integer bizType, String bizId);
/**
* 扣减会员经验
*
* @param userId 会员ID
* @param experience 经验
* @param bizType 业务类型 {@link MemberExperienceBizTypeEnum}
* @param bizId 业务编号
*/
void reduceExperience(Long userId, Integer experience, Integer bizType, String bizId);
}
package org.dromara.mall.api.service.member;
import jakarta.validation.constraints.Min;
/**
* 用户积分的 API 接口
*
* @author owen
*/
public interface MemberPointApi {
/**
* 增加用户积分
*
* @param userId 用户编号
* @param point 积分
* @param bizType 业务类型 {@link org.dromara.mall.enums.member.point.MemberPointBizTypeEnum}
* @param bizId 业务编号
*/
void addPoint(Long userId, @Min(value = 1L, message = "积分必须是正数") Integer point,
Integer bizType, String bizId);
/**
* 减少用户积分
*
* @param userId 用户编号
* @param point 积分
* @param bizType 业务类型 {@link org.dromara.mall.enums.member.point.MemberPointBizTypeEnum}
* @param bizId 业务编号
*/
void reducePoint(Long userId, @Min(value = 1L, message = "积分必须是正数") Integer point,
Integer bizType, String bizId);
}
package org.dromara.mall.api.service.member;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
/**
* 会员用户的 API 接口
*
* @author 芋道源码
*/
public interface MemberUserApi {
/**
* 获得会员用户信息
*
* @param id 用户编号
* @return 用户信息
*/
MemberUserRespDTO getUser(Long id);
/**
* 获得会员用户信息们
*
* @param ids 用户编号的数组
* @return 用户信息们
*/
List<MemberUserRespDTO> getUserList(Collection<Long> ids);
/**
* 获得会员用户 Map
*
* @param ids 用户编号的数组
* @return 会员用户 Map
*/
default Map<Long, MemberUserRespDTO> getUserMap(Collection<Long> ids) {
List<MemberUserRespDTO> list = getUserList(ids);
return convertMap(list, MemberUserRespDTO::getId);
}
/**
* 基于用户昵称,模糊匹配用户列表
*
* @param nickname 用户昵称,模糊匹配
* @return 用户信息的列表
*/
List<MemberUserRespDTO> getUserListByNickname(String nickname);
/**
* 基于手机号,精准匹配用户
*
* @param mobile 手机号
* @return 用户信息
*/
MemberUserRespDTO getUserByMobile(String mobile);
/**
* 校验用户是否存在
*
* @param id 用户编号
*/
void validateUser(Long id);
}
package org.dromara.mall.api.service.member.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.member.MemberAddressRespDTO;
import org.dromara.mall.api.service.member.MemberAddressApi;
import org.dromara.mall.convert.member.AddressConvert;
import org.dromara.mall.service.member.AddressService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 用户收件地址 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class MemberAddressApiImpl implements MemberAddressApi {
@Resource
private AddressService addressService;
@Override
public MemberAddressRespDTO getAddress(Long id, Long userId) {
return AddressConvert.INSTANCE.convert02(addressService.getAddress(userId, id));
}
@Override
public MemberAddressRespDTO getDefaultAddress(Long userId) {
return AddressConvert.INSTANCE.convert02(addressService.getDefaultUserAddress(userId));
}
}
package org.dromara.mall.api.service.member.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.member.MemberConfigRespDTO;
import org.dromara.mall.api.service.member.MemberConfigApi;
import org.dromara.mall.convert.member.MemberConfigConvert;
import org.dromara.mall.service.member.MemberConfigService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 用户配置 API 实现类
*
* @author owen
*/
@Service
@Validated
public class MemberConfigApiImpl implements MemberConfigApi {
@Resource
private MemberConfigService memberConfigService;
@Override
public MemberConfigRespDTO getConfig() {
return MemberConfigConvert.INSTANCE.convert01(memberConfigService.getConfig());
}
}
package org.dromara.mall.api.service.member.impl;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.dromara.mall.api.dto.member.MemberLevelRespDTO;
import org.dromara.mall.api.service.member.MemberLevelApi;
import org.dromara.mall.convert.member.MemberLevelConvert;
import org.dromara.mall.enums.member.experience.MemberExperienceBizTypeEnum;
import org.dromara.mall.service.member.MemberLevelService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
;import static org.dromara.common.mall.exception.util.ServiceExceptionUtil.exception;
import static org.dromara.mall.enums.member.ErrorCodeConstants.EXPERIENCE_BIZ_NOT_SUPPORT;
/**
* 会员等级 API 实现类
*
* @author owen
*/
@Slf4j
@Service
@Validated
public class MemberLevelApiImpl implements MemberLevelApi {
@Resource
private MemberLevelService memberLevelService;
@Override
public MemberLevelRespDTO getMemberLevel(Long id) {
return MemberLevelConvert.INSTANCE.convert02(memberLevelService.getLevel(id));
}
@Override
public void addExperience(Long userId, Integer experience, Integer bizType, String bizId) {
MemberExperienceBizTypeEnum bizTypeEnum = MemberExperienceBizTypeEnum.getByType(bizType);
if (bizTypeEnum == null) {
throw exception(EXPERIENCE_BIZ_NOT_SUPPORT);
}
memberLevelService.addExperience(userId, experience, bizTypeEnum, bizId);
}
@Override
public void reduceExperience(Long userId, Integer experience, Integer bizType, String bizId) {
addExperience(userId, -experience, bizType, bizId);
}
}
package org.dromara.mall.api.service.member.impl;
import cn.hutool.core.lang.Assert;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.dromara.mall.api.service.member.MemberPointApi;
import org.dromara.mall.enums.member.point.MemberPointBizTypeEnum;
import org.dromara.mall.service.member.MemberPointRecordService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import static org.dromara.common.mall.exception.util.ServiceExceptionUtil.exception;
import static org.dromara.mall.enums.member.ErrorCodeConstants.POINT_RECORD_BIZ_NOT_SUPPORT;
/**
* 用户积分的 API 实现类
*
* @author owen
*/
@Slf4j
@Service
@Validated
public class MemberPointApiImpl implements MemberPointApi {
@Resource
private MemberPointRecordService memberPointRecordService;
@Override
public void addPoint(Long userId, Integer point, Integer bizType, String bizId) {
Assert.isTrue(point > 0);
MemberPointBizTypeEnum bizTypeEnum = MemberPointBizTypeEnum.getByType(bizType);
if (bizTypeEnum == null) {
log.error("[addPoint][userId({}) point({}) bizType({}) bizId({}) {}]", userId, point, bizType, bizId,
POINT_RECORD_BIZ_NOT_SUPPORT);
return;
}
memberPointRecordService.createPointRecord(userId, point, bizTypeEnum, bizId);
}
@Override
public void reducePoint(Long userId, Integer point, Integer bizType, String bizId) {
Assert.isTrue(point > 0);
MemberPointBizTypeEnum bizTypeEnum = MemberPointBizTypeEnum.getByType(bizType);
if (bizTypeEnum == null) {
throw exception(POINT_RECORD_BIZ_NOT_SUPPORT);
}
memberPointRecordService.createPointRecord(userId, -point, bizTypeEnum, bizId);
}
}
package org.dromara.mall.api.service.member.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.service.member.MemberUserApi;
import org.dromara.mall.convert.member.MemberUserConvert;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.domain.member.MemberUserDO;
import org.dromara.mall.service.member.MemberUserService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.Collection;
import java.util.List;
import static org.dromara.common.mall.exception.util.ServiceExceptionUtil.exception;
import static org.dromara.mall.enums.member.ErrorCodeConstants.USER_MOBILE_NOT_EXISTS;
/**
* 会员用户的 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class MemberUserApiImpl implements MemberUserApi {
@Resource
private MemberUserService userService;
@Override
public MemberUserRespDTO getUser(Long id) {
MemberUserDO user = userService.getUser(id);
return MemberUserConvert.INSTANCE.convert2(user);
}
@Override
public List<MemberUserRespDTO> getUserList(Collection<Long> ids) {
return MemberUserConvert.INSTANCE.convertList2(userService.getUserList(ids));
}
@Override
public List<MemberUserRespDTO> getUserListByNickname(String nickname) {
return MemberUserConvert.INSTANCE.convertList2(userService.getUserListByNickname(nickname));
}
@Override
public MemberUserRespDTO getUserByMobile(String mobile) {
return MemberUserConvert.INSTANCE.convert2(userService.getUserByMobile(mobile));
}
@Override
public void validateUser(Long id) {
MemberUserDO user = userService.getUser(id);
if (user == null) {
throw exception(USER_MOBILE_NOT_EXISTS);
}
}
}
package org.dromara.mall.api.service.pay;
import jakarta.validation.Valid;
import org.dromara.mall.api.dto.pay.PayOrderCreateReqDTO;
import org.dromara.mall.api.dto.pay.PayOrderRespDTO;
/**
* 支付单 API 接口
*
* @author LeeYan9
* @since 2022-08-26
*/
public interface PayOrderApi {
/**
* 创建支付单
*
* @param reqDTO 创建请求
* @return 支付单编号
*/
Long createOrder(@Valid PayOrderCreateReqDTO reqDTO);
/**
* 获得支付单
*
* @param id 支付单编号
* @return 支付单
*/
PayOrderRespDTO getOrder(Long id);
/**
* 更新支付订单价格
*
* @param id 支付单编号
* @param payPrice 支付单价格
*/
void updatePayOrderPrice(Long id, Integer payPrice);
}
package org.dromara.mall.api.service.pay;
import jakarta.validation.Valid;
import org.dromara.mall.api.dto.pay.PayRefundCreateReqDTO;
import org.dromara.mall.api.dto.pay.PayRefundRespDTO;
/**
* 退款单 API 接口
*
* @author 芋道源码
*/
public interface PayRefundApi {
/**
* 创建退款单
*
* @param reqDTO 创建请求
* @return 退款单编号
*/
Long createRefund(@Valid PayRefundCreateReqDTO reqDTO);
/**
* 获得退款单
*
* @param id 退款单编号
* @return 退款单
*/
PayRefundRespDTO getRefund(Long id);
}
package org.dromara.mall.api.service.pay;
import jakarta.validation.Valid;
import org.dromara.common.pay.core.client.dto.transfer.PayTransferRespDTO;
import org.dromara.mall.api.dto.pay.PayTransferCreateReqDTO;
/**
* 转账单 API 接口
*
* @author jason
*/
public interface PayTransferApi {
/**
* 创建转账单
*
* @param reqDTO 创建请求
* @return 转账单编号
*/
Long createTransfer(@Valid PayTransferCreateReqDTO reqDTO);
/**
* 获得转账单
*
* @param id 转账单编号
* @return 转账单
*/
PayTransferRespDTO getTransfer(Long id);
}
package org.dromara.mall.api.service.pay;
import org.dromara.mall.api.dto.pay.PayWalletAddBalanceReqDTO;
/**
* 钱包 API 接口
*
* @author liurulin
*/
public interface PayWalletApi {
/**
* 添加钱包余额
*
* @param reqDTO 增加余额请求
*/
void addWalletBalance(PayWalletAddBalanceReqDTO reqDTO);
}
package org.dromara.mall.api.service.pay.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.pay.PayOrderCreateReqDTO;
import org.dromara.mall.api.dto.pay.PayOrderRespDTO;
import org.dromara.mall.api.service.pay.PayOrderApi;
import org.dromara.mall.convert.pay.PayOrderConvert;
import org.dromara.mall.domain.pay.PayOrderDO;
import org.dromara.mall.service.pay.PayOrderService;
import org.springframework.stereotype.Service;
/**
* 支付单 API 实现类
*
* @author 芋道源码
*/
@Service
public class PayOrderApiImpl implements PayOrderApi {
@Resource
private PayOrderService payOrderService;
@Override
public Long createOrder(PayOrderCreateReqDTO reqDTO) {
return payOrderService.createOrder(reqDTO);
}
@Override
public PayOrderRespDTO getOrder(Long id) {
PayOrderDO order = payOrderService.getOrder(id);
return PayOrderConvert.INSTANCE.convert2(order);
}
@Override
public void updatePayOrderPrice(Long id, Integer payPrice) {
payOrderService.updatePayOrderPrice(id, payPrice);
}
}
package org.dromara.mall.api.service.pay.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.pay.PayRefundCreateReqDTO;
import org.dromara.mall.api.dto.pay.PayRefundRespDTO;
import org.dromara.mall.api.service.pay.PayRefundApi;
import org.dromara.mall.convert.pay.PayRefundConvert;
import org.dromara.mall.service.pay.PayRefundService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 退款单 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class PayRefundApiImpl implements PayRefundApi {
@Resource
private PayRefundService payRefundService;
@Override
public Long createRefund(PayRefundCreateReqDTO reqDTO) {
return payRefundService.createPayRefund(reqDTO);
}
@Override
public PayRefundRespDTO getRefund(Long id) {
return PayRefundConvert.INSTANCE.convert02(payRefundService.getRefund(id));
}
}
package org.dromara.mall.api.service.pay.impl;
import jakarta.annotation.Resource;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.common.pay.core.client.dto.transfer.PayTransferRespDTO;
import org.dromara.mall.api.dto.pay.PayTransferCreateReqDTO;
import org.dromara.mall.api.service.pay.PayTransferApi;
import org.dromara.mall.domain.pay.PayTransferDO;
import org.dromara.mall.service.pay.PayTransferService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 转账单 API 实现类
*
* @author jason
*/
@Service
@Validated
public class PayTransferApiImpl implements PayTransferApi {
@Resource
private PayTransferService payTransferService;
@Override
public Long createTransfer(PayTransferCreateReqDTO reqDTO) {
return payTransferService.createTransfer(reqDTO);
}
@Override
public PayTransferRespDTO getTransfer(Long id) {
PayTransferDO transfer = payTransferService.getTransfer(id);
return BeanUtils.toBean(transfer, PayTransferRespDTO.class);
}
}
package org.dromara.mall.api.service.pay.impl;
import cn.hutool.core.lang.Assert;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.pay.PayWalletAddBalanceReqDTO;
import org.dromara.mall.api.service.pay.PayWalletApi;
import org.dromara.mall.domain.pay.PayWalletDO;
import org.dromara.mall.enums.pay.wallet.PayWalletBizTypeEnum;
import org.dromara.mall.service.pay.PayWalletService;
import org.springframework.stereotype.Service;
/**
* 钱包 API 实现类
*
* @author 芋道源码
*/
@Service
public class PayWalletApiImpl implements PayWalletApi {
@Resource
private PayWalletService payWalletService;
@Override
public void addWalletBalance(PayWalletAddBalanceReqDTO reqDTO) {
// 创建或获取钱包
PayWalletDO wallet = payWalletService.getOrCreateWallet(reqDTO.getUserId(), reqDTO.getUserType());
Assert.notNull(wallet, "钱包({}/{})不存在", reqDTO.getUserId(), reqDTO.getUserType());
// 增加余额
PayWalletBizTypeEnum bizType = PayWalletBizTypeEnum.valueOf(reqDTO.getBizType());
payWalletService.addWalletBalance(wallet.getId(), reqDTO.getBizId(), bizType, reqDTO.getPrice());
}
}
package org.dromara.mall.api.service.product;
import java.util.Collection;
/**
* 商品分类 API 接口
*
* @author owen
*/
public interface ProductCategoryApi {
/**
* 校验商品分类是否有效。如下情况,视为无效:
* 1. 商品分类编号不存在
* 2. 商品分类被禁用
*
* @param ids 商品分类编号数组
*/
void validateCategoryList(Collection<Long> ids);
}
package org.dromara.mall.api.service.product;
import org.dromara.mall.api.dto.product.ProductCommentCreateReqDTO;
/**
* 产品评论 API 接口
*
* @author HUIHUI
*/
public interface ProductCommentApi {
/**
* 创建评论
*
* @param createReqDTO 评论参数
* @return 返回评论创建后的 id
*/
Long createComment(ProductCommentCreateReqDTO createReqDTO);
}
package org.dromara.mall.api.service.product;
import org.dromara.mall.api.dto.product.ProductSkuRespDTO;
import org.dromara.mall.api.dto.product.ProductSkuUpdateStockReqDTO;
import java.util.Collection;
import java.util.List;
/**
* 商品 SKU API 接口
*
* @author LeeYan9
* @since 2022-08-26
*/
public interface ProductSkuApi {
/**
* 查询 SKU 信息
*
* @param id SKU 编号
* @return SKU 信息
*/
ProductSkuRespDTO getSku(Long id);
/**
* 批量查询 SKU 数组
*
* @param ids SKU 编号列表
* @return SKU 数组
*/
List<ProductSkuRespDTO> getSkuList(Collection<Long> ids);
/**
* 批量查询 SKU 数组
*
* @param spuIds SPU 编号列表
* @return SKU 数组
*/
List<ProductSkuRespDTO> getSkuListBySpuId(Collection<Long> spuIds);
/**
* 更新 SKU 库存(增加 or 减少)
*
* @param updateStockReqDTO 更新请求
*/
void updateSkuStock(ProductSkuUpdateStockReqDTO updateStockReqDTO);
}
package org.dromara.mall.api.service.product;
import org.dromara.mall.api.dto.product.ProductSpuRespDTO;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
/**
* 商品 SPU API 接口
*
* @author LeeYan9
* @since 2022-08-26
*/
public interface ProductSpuApi {
/**
* 批量查询 SPU 数组
*
* @param ids SPU 编号列表
* @return SPU 数组
*/
List<ProductSpuRespDTO> getSpuList(Collection<Long> ids);
/**
* 批量查询 SPU MAP
*
* @param ids SPU 编号列表
* @return SPU MAP
*/
default Map<Long, ProductSpuRespDTO> getSpusMap(Collection<Long> ids) {
return convertMap(getSpuList(ids), ProductSpuRespDTO::getId);
}
/**
* 批量查询 SPU 数组,并且校验是否 SPU 是否有效。
*
* 如下情况,视为无效:
* 1. 商品编号不存在
* 2. 商品被禁用
*
* @param ids SPU 编号列表
* @return SPU 数组
*/
List<ProductSpuRespDTO> validateSpuList(Collection<Long> ids);
/**
* 获得 SPU
*
* @return SPU
*/
ProductSpuRespDTO getSpu(Long id);
}
package org.dromara.mall.api.service.product.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.service.product.ProductCategoryApi;
import org.dromara.mall.service.product.ProductCategoryService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.Collection;
/**
* 商品分类 API 接口实现类
*
* @author owen
*/
@Service
@Validated
public class ProductCategoryApiImpl implements ProductCategoryApi {
@Resource
private ProductCategoryService productCategoryService;
@Override
public void validateCategoryList(Collection<Long> ids) {
productCategoryService.validateCategoryList(ids);
}
}
package org.dromara.mall.api.service.product.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.product.ProductCommentCreateReqDTO;
import org.dromara.mall.api.service.product.ProductCommentApi;
import org.dromara.mall.service.product.ProductCommentService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 商品评论 API 实现类
*
* @author HUIHUI
*/
@Service
@Validated
public class ProductCommentApiImpl implements ProductCommentApi {
@Resource
private ProductCommentService productCommentService;
@Override
public Long createComment(ProductCommentCreateReqDTO createReqDTO) {
return productCommentService.createComment(createReqDTO);
}
}
package org.dromara.mall.api.service.product.impl;
import jakarta.annotation.Resource;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.api.dto.product.ProductSkuRespDTO;
import org.dromara.mall.api.dto.product.ProductSkuUpdateStockReqDTO;
import org.dromara.mall.api.service.product.ProductSkuApi;
import org.dromara.mall.domain.product.ProductSkuDO;
import org.dromara.mall.service.product.ProductSkuService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.Collection;
import java.util.List;
/**
* 商品 SKU API 实现类
*
* @author LeeYan9
* @since 2022-09-06
*/
@Service
@Validated
public class ProductSkuApiImpl implements ProductSkuApi {
@Resource
private ProductSkuService productSkuService;
@Override
public ProductSkuRespDTO getSku(Long id) {
ProductSkuDO sku = productSkuService.getSku(id);
return BeanUtils.toBean(sku, ProductSkuRespDTO.class);
}
@Override
public List<ProductSkuRespDTO> getSkuList(Collection<Long> ids) {
List<ProductSkuDO> skus = productSkuService.getSkuList(ids);
return BeanUtils.toBean(skus, ProductSkuRespDTO.class);
}
@Override
public List<ProductSkuRespDTO> getSkuListBySpuId(Collection<Long> spuIds) {
List<ProductSkuDO> skus = productSkuService.getSkuListBySpuId(spuIds);
return BeanUtils.toBean(skus, ProductSkuRespDTO.class);
}
@Override
public void updateSkuStock(ProductSkuUpdateStockReqDTO updateStockReqDTO) {
productSkuService.updateSkuStock(updateStockReqDTO);
}
}
package org.dromara.mall.api.service.product.impl;
import jakarta.annotation.Resource;
import org.dromara.common.mall.util.object.BeanUtils;
import org.dromara.mall.api.dto.product.ProductSpuRespDTO;
import org.dromara.mall.api.service.product.ProductSpuApi;
import org.dromara.mall.domain.product.ProductSpuDO;
import org.dromara.mall.service.product.ProductSpuService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.Collection;
import java.util.List;
/**
* 商品 SPU API 接口实现类
*
* @author LeeYan9
* @since 2022-09-06
*/
@Service
@Validated
public class ProductSpuApiImpl implements ProductSpuApi {
@Resource
private ProductSpuService spuService;
@Override
public List<ProductSpuRespDTO> getSpuList(Collection<Long> ids) {
List<ProductSpuDO> spus = spuService.getSpuList(ids);
return BeanUtils.toBean(spus, ProductSpuRespDTO.class);
}
@Override
public List<ProductSpuRespDTO> validateSpuList(Collection<Long> ids) {
List<ProductSpuDO> spus = spuService.validateSpuList(ids);
return BeanUtils.toBean(spus, ProductSpuRespDTO.class);
}
@Override
public ProductSpuRespDTO getSpu(Long id) {
ProductSpuDO spu = spuService.getSpu(id);
return BeanUtils.toBean(spu, ProductSpuRespDTO.class);
}
}
package org.dromara.mall.api.service.promotion;
/**
* 砍价活动 Api 接口
*
* @author HUIHUI
*/
public interface BargainActivityApi {
/**
* 更新砍价活动库存
*
* @param id 砍价活动编号
* @param count 购买数量
*/
void updateBargainActivityStock(Long id, Integer count);
}
package org.dromara.mall.api.service.promotion;
import org.dromara.mall.api.dto.promotion.BargainValidateJoinRespDTO;
/**
* 砍价记录 API 接口
*
* @author HUIHUI
*/
public interface BargainRecordApi {
/**
* 【下单前】校验是否参与砍价活动
* <p>
* 如果校验失败,则抛出业务异常
*
* @param userId 用户编号
* @param bargainRecordId 砍价活动编号
* @param skuId SKU 编号
* @return 砍价信息
*/
BargainValidateJoinRespDTO validateJoinBargain(Long userId, Long bargainRecordId, Long skuId);
/**
* 更新砍价记录的订单编号
*
* 在砍价成功后,用户发起订单后,会记录该订单编号
*
* @param id 砍价记录编号
* @param orderId 订单编号
*/
void updateBargainRecordOrderId(Long id, Long orderId);
}
package org.dromara.mall.api.service.promotion;
import jakarta.validation.Valid;
import org.dromara.mall.api.dto.promotion.CombinationRecordCreateReqDTO;
import org.dromara.mall.api.dto.promotion.CombinationRecordCreateRespDTO;
import org.dromara.mall.api.dto.promotion.CombinationRecordRespDTO;
import org.dromara.mall.api.dto.promotion.CombinationValidateJoinRespDTO;
/**
* 拼团记录 API 接口
*
* @author HUIHUI
*/
public interface CombinationRecordApi {
/**
* 校验是否满足拼团条件
*
* @param userId 用户编号
* @param activityId 活动编号
* @param headId 团长编号
* @param skuId sku 编号
* @param count 数量
*/
void validateCombinationRecord(Long userId, Long activityId, Long headId, Long skuId, Integer count);
/**
* 创建开团记录
*
* @param reqDTO 请求 DTO
* @return 拼团信息
*/
CombinationRecordCreateRespDTO createCombinationRecord(@Valid CombinationRecordCreateReqDTO reqDTO);
/**
* 基于订单编号,查询拼团记录
*
* @param userId 用户编号
* @param orderId 订单编号
* @return 拼团记录
*/
CombinationRecordRespDTO getCombinationRecordByOrderId(Long userId, Long orderId);
/**
* 【下单前】校验是否满足拼团活动条件
* <p>
* 如果校验失败,则抛出业务异常
*
* @param userId 用户编号
* @param activityId 活动编号
* @param headId 团长编号
* @param skuId sku 编号
* @param count 数量
* @return 拼团信息
*/
CombinationValidateJoinRespDTO validateJoinCombination(Long userId, Long activityId, Long headId,
Long skuId, Integer count);
}
package org.dromara.mall.api.service.promotion;
import jakarta.validation.Valid;
import org.dromara.mall.api.dto.promotion.CouponRespDTO;
import org.dromara.mall.api.dto.promotion.CouponUseReqDTO;
import java.util.List;
import java.util.Map;
/**
* 优惠劵 API 接口
*
* @author 芋道源码
*/
public interface CouponApi {
/**
* 获得用户的优惠劵列表
*
* @param userId 用户编号
* @param status 优惠劵状态
* @return 优惠劵列表
*/
List<CouponRespDTO> getCouponListByUserId(Long userId, Integer status);
/**
* 使用优惠劵
*
* @param useReqDTO 使用请求
*/
void useCoupon(@Valid CouponUseReqDTO useReqDTO);
/**
* 退还已使用的优惠券
*
* @param id 优惠券编号
*/
void returnUsedCoupon(Long id);
/**
* 【管理员】给指定用户批量发送优惠券
*
* @param giveCoupons key: 优惠劵模版编号,value:对应的数量
* @param userId 用户编号
* @return 优惠券编号列表
*/
List<Long> takeCouponsByAdmin(Map<Long, Integer> giveCoupons, Long userId);
/**
* 【管理员】作废指定用户的指定优惠劵
*
* @param giveCouponIds 赠送的优惠券编号
* @param userId 用户编号
*/
void invalidateCouponsByAdmin(List<Long> giveCouponIds, Long userId);
}
package org.dromara.mall.api.service.promotion;
import org.dromara.mall.api.dto.promotion.DiscountProductRespDTO;
import java.util.Collection;
import java.util.List;
/**
* 限时折扣 API 接口
*
* @author 芋道源码
*/
public interface DiscountActivityApi {
/**
* 获得 skuId 商品匹配的的限时折扣信息
*
* @param skuIds 商品 SKU 编号数组
* @return 限时折扣信息
*/
List<DiscountProductRespDTO> getMatchDiscountProductListBySkuIds(Collection<Long> skuIds);
}
package org.dromara.mall.api.service.promotion;
import org.dromara.mall.api.dto.promotion.PointValidateJoinRespDTO;
/**
* 积分商城活动 API 接口
*
* @author HUIHUI
*/
public interface PointActivityApi {
/**
* 【下单前】校验是否参与积分商城活动
*
* 如果校验失败,则抛出业务异常
*
* @param activityId 活动编号
* @param skuId SKU 编号
* @param count 数量
* @return 积分商城商品信息
*/
PointValidateJoinRespDTO validateJoinPointActivity(Long activityId, Long skuId, Integer count);
/**
* 更新积分商城商品库存(减少)
*
* @param id 活动编号
* @param skuId sku 编号
* @param count 数量(正数)
*/
void updatePointStockDecr(Long id, Long skuId, Integer count);
/**
* 更新积分商城商品库存(增加)
*
* @param id 活动编号
* @param skuId sku 编号
* @param count 数量(正数)
*/
void updatePointStockIncr(Long id, Long skuId, Integer count);
}
package org.dromara.mall.api.service.promotion;
import org.dromara.mall.api.dto.promotion.RewardActivityMatchRespDTO;
import java.util.Collection;
import java.util.List;
/**
* 满减送活动 API 接口
*
* @author 芋道源码
*/
public interface RewardActivityApi {
/**
* 获得 spuId 商品匹配的的满减送活动列表
*
* @param spuIds SPU 编号
* @return 满减送活动列表
*/
List<RewardActivityMatchRespDTO> getMatchRewardActivityListBySpuIds(Collection<Long> spuIds);
}
package org.dromara.mall.api.service.promotion;
import org.dromara.mall.api.dto.promotion.SeckillValidateJoinRespDTO;
/**
* 秒杀活动 API 接口
*
* @author HUIHUI
*/
public interface SeckillActivityApi {
/**
* 更新秒杀库存(减少)
*
* @param id 活动编号
* @param skuId sku 编号
* @param count 数量(正数)
*/
void updateSeckillStockDecr(Long id, Long skuId, Integer count);
/**
* 更新秒杀库存(增加)
*
* @param id 活动编号
* @param skuId sku 编号
* @param count 数量(正数)
*/
void updateSeckillStockIncr(Long id, Long skuId, Integer count);
/**
* 【下单前】校验是否参与秒杀活动
*
* 如果校验失败,则抛出业务异常
*
* @param activityId 活动编号
* @param skuId SKU 编号
* @param count 数量
* @return 秒杀信息
*/
SeckillValidateJoinRespDTO validateJoinSeckill(Long activityId, Long skuId, Integer count);
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.service.promotion.BargainActivityApi;
import org.dromara.mall.service.promotion.BargainActivityService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 砍价活动 Api 接口实现类
*
* @author HUIHUI
*/
@Service
@Validated
public class BargainActivityApiImpl implements BargainActivityApi {
@Resource
private BargainActivityService bargainActivityService;
@Override
public void updateBargainActivityStock(Long id, Integer count) {
bargainActivityService.updateBargainActivityStock(id, count);
}
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.promotion.BargainValidateJoinRespDTO;
import org.dromara.mall.api.service.promotion.BargainRecordApi;
import org.dromara.mall.service.promotion.BargainRecordService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 砍价活动 API 实现类
*
* @author HUIHUI
*/
@Service
@Validated
public class BargainRecordApiImpl implements BargainRecordApi {
@Resource
private BargainRecordService bargainRecordService;
@Override
public BargainValidateJoinRespDTO validateJoinBargain(Long userId, Long bargainRecordId, Long skuId) {
return bargainRecordService.validateJoinBargain(userId, bargainRecordId, skuId);
}
@Override
public void updateBargainRecordOrderId(Long id, Long orderId) {
bargainRecordService.updateBargainRecordOrderId(id, orderId);
}
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.api.dto.promotion.CombinationRecordCreateReqDTO;
import org.dromara.mall.api.dto.promotion.CombinationRecordCreateRespDTO;
import org.dromara.mall.api.dto.promotion.CombinationRecordRespDTO;
import org.dromara.mall.api.dto.promotion.CombinationValidateJoinRespDTO;
import org.dromara.mall.api.service.promotion.CombinationRecordApi;
import org.dromara.mall.convert.promotion.combination.CombinationActivityConvert;
import org.dromara.mall.domain.promotion.CombinationRecordDO;
import org.dromara.mall.service.promotion.CombinationRecordService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 拼团活动 API 实现类
*
* @author HUIHUI
*/
@Service
@Validated
public class CombinationRecordApiImpl implements CombinationRecordApi {
@Resource
private CombinationRecordService combinationRecordService;
@Override
public void validateCombinationRecord(Long userId, Long activityId, Long headId, Long skuId, Integer count) {
combinationRecordService.validateCombinationRecord(userId, activityId, headId, skuId, count);
}
@Override
public CombinationRecordCreateRespDTO createCombinationRecord(CombinationRecordCreateReqDTO reqDTO) {
return CombinationActivityConvert.INSTANCE.convert4(combinationRecordService.createCombinationRecord(reqDTO));
}
@Override
public CombinationRecordRespDTO getCombinationRecordByOrderId(Long userId, Long orderId) {
CombinationRecordDO record = combinationRecordService.getCombinationRecord(userId, orderId);
return BeanUtils.toBean(record, CombinationRecordRespDTO.class);
}
@Override
public CombinationValidateJoinRespDTO validateJoinCombination(Long userId, Long activityId, Long headId, Long skuId, Integer count) {
return combinationRecordService.validateJoinCombination(userId, activityId, headId, skuId, count);
}
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.api.dto.promotion.CouponRespDTO;
import org.dromara.mall.api.dto.promotion.CouponUseReqDTO;
import org.dromara.mall.api.service.promotion.CouponApi;
import org.dromara.mall.service.promotion.CouponService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.List;
import java.util.Map;
/**
* 优惠劵 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class CouponApiImpl implements CouponApi {
@Resource
private CouponService couponService;
@Override
public List<CouponRespDTO> getCouponListByUserId(Long userId, Integer status) {
return BeanUtils.toBean(couponService.getCouponList(userId, status), CouponRespDTO.class);
}
@Override
public void useCoupon(CouponUseReqDTO useReqDTO) {
couponService.useCoupon(useReqDTO.getId(), useReqDTO.getUserId(),
useReqDTO.getOrderId());
}
@Override
public void returnUsedCoupon(Long id) {
couponService.returnUsedCoupon(id);
}
@Override
public List<Long> takeCouponsByAdmin(Map<Long, Integer> giveCoupons, Long userId) {
return couponService.takeCouponsByAdmin(giveCoupons, userId);
}
@Override
public void invalidateCouponsByAdmin(List<Long> giveCouponIds, Long userId) {
couponService.invalidateCouponsByAdmin(giveCouponIds, userId);
}
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.api.dto.promotion.DiscountProductRespDTO;
import org.dromara.mall.api.service.promotion.DiscountActivityApi;
import org.dromara.mall.domain.promotion.DiscountProductDO;
import org.dromara.mall.service.promotion.DiscountActivityService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.Collection;
import java.util.List;
/**
* 限时折扣 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class DiscountActivityApiImpl implements DiscountActivityApi {
@Resource
private DiscountActivityService discountActivityService;
@Override
public List<DiscountProductRespDTO> getMatchDiscountProductListBySkuIds(Collection<Long> skuIds) {
List<DiscountProductDO> list = discountActivityService.getMatchDiscountProductListBySkuIds(skuIds);
return BeanUtils.toBean(list, DiscountProductRespDTO.class);
}
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.promotion.PointValidateJoinRespDTO;
import org.dromara.mall.api.service.promotion.PointActivityApi;
import org.dromara.mall.service.promotion.PointActivityService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 积分商城活动 Api 接口实现类
*
* @author HUIHUI
*/
@Service
@Validated
public class PointActivityApiImpl implements PointActivityApi {
@Resource
private PointActivityService pointActivityService;
@Override
public PointValidateJoinRespDTO validateJoinPointActivity(Long activityId, Long skuId, Integer count) {
return pointActivityService.validateJoinPointActivity(activityId, skuId, count);
}
@Override
public void updatePointStockDecr(Long id, Long skuId, Integer count) {
pointActivityService.updatePointStockDecr(id, skuId, count);
}
@Override
public void updatePointStockIncr(Long id, Long skuId, Integer count) {
pointActivityService.updatePointStockIncr(id, skuId, count);
}
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.promotion.RewardActivityMatchRespDTO;
import org.dromara.mall.api.service.promotion.RewardActivityApi;
import org.dromara.mall.service.promotion.RewardActivityService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.Collection;
import java.util.List;
/**
* 满减送活动 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class RewardActivityApiImpl implements RewardActivityApi {
@Resource
private RewardActivityService rewardActivityService;
@Override
public List<RewardActivityMatchRespDTO> getMatchRewardActivityListBySpuIds(Collection<Long> spuIds) {
return rewardActivityService.getMatchRewardActivityListBySpuIds(spuIds);
}
}
package org.dromara.mall.api.service.promotion.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.promotion.SeckillValidateJoinRespDTO;
import org.dromara.mall.api.service.promotion.SeckillActivityApi;
import org.dromara.mall.service.promotion.SeckillActivityService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 秒杀活动接口 Api 接口实现类
*
* @author HUIHUI
*/
@Service
@Validated
public class SeckillActivityApiImpl implements SeckillActivityApi {
@Resource
private SeckillActivityService activityService;
@Override
public void updateSeckillStockDecr(Long id, Long skuId, Integer count) {
activityService.updateSeckillStockDecr(id, skuId, count);
}
@Override
public void updateSeckillStockIncr(Long id, Long skuId, Integer count) {
activityService.updateSeckillStockIncr(id, skuId, count);
}
@Override
public SeckillValidateJoinRespDTO validateJoinSeckill(Long activityId, Long skuId, Integer count) {
return activityService.validateJoinSeckill(activityId, skuId, count);
}
}
package org.dromara.mall.api.service.system;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.mall.api.dto.system.AdminUserRespDTO;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
* Admin 用户 API 接口
*
* @author 芋道源码
*/
public interface AdminUserApi {
/**
* 通过用户 ID 查询用户
*
* @param id 用户ID
* @return 用户对象信息
*/
AdminUserRespDTO getUser(Long id);
/**
* 通过用户 ID 查询用户们
*
* @param ids 用户 ID 们
* @return 用户对象信息
*/
List<AdminUserRespDTO> getUserList(Collection<Long> ids);
/**
* 获得用户 Map
*
* @param ids 用户编号数组
* @return 用户 Map
*/
default Map<Long, AdminUserRespDTO> getUserMap(Collection<Long> ids) {
List<AdminUserRespDTO> users = getUserList(ids);
return CollectionUtils.convertMap(users, AdminUserRespDTO::getId);
}
/**
* 校验用户是否有效。如下情况,视为无效:
* 1. 用户编号不存在
* 2. 用户被禁用
*
* @param id 用户编号
*/
default void validateUser(Long id) {
validateUserList(Collections.singleton(id));
}
/**
* 校验用户们是否有效。如下情况,视为无效:
* 1. 用户编号不存在
* 2. 用户被禁用
*
* @param ids 用户编号数组
*/
void validateUserList(Collection<Long> ids);
}
package org.dromara.mall.api.service.system;
import jakarta.validation.Valid;
import org.dromara.mall.api.dto.system.NotifySendSingleToUserReqDTO;
/**
* 站内信发送 API 接口
*
* @author xrcoder
*/
public interface NotifyMessageSendApi {
/**
* 发送单条站内信给 Admin 用户
*
* @param reqDTO 发送请求
* @return 发送消息 ID
*/
Long sendSingleMessageToAdmin(@Valid NotifySendSingleToUserReqDTO reqDTO);
/**
* 发送单条站内信给 Member 用户
*
* @param reqDTO 发送请求
* @return 发送消息 ID
*/
Long sendSingleMessageToMember(@Valid NotifySendSingleToUserReqDTO reqDTO);
}
package org.dromara.mall.api.service.system;
import jakarta.validation.Valid;
import org.dromara.mall.api.dto.member.SocialWxPhoneNumberInfoRespDTO;
import org.dromara.mall.api.dto.member.SocialWxQrcodeReqDTO;
import org.dromara.mall.api.dto.member.SocialWxaSubscribeMessageSendReqDTO;
import org.dromara.mall.api.dto.member.SocialWxaSubscribeTemplateRespDTO;
import org.dromara.mall.api.dto.system.SocialWxJsapiSignatureRespDTO;
import java.util.List;
/**
* 社交应用的 API 接口
*
* @author 芋道源码
*/
public interface SocialClientApi {
/**
* 获得社交平台的授权 URL
*
* @param socialType 社交平台的类型 {@link SocialTypeEnum}
* @param userType 用户类型
* @param redirectUri 重定向 URL
* @return 社交平台的授权 URL
*/
String getAuthorizeUrl(Integer socialType, Integer userType, String redirectUri);
/**
* 创建微信公众号 JS SDK 初始化所需的签名
*
* @param userType 用户类型
* @param url 访问的 URL 地址
* @return 签名
*/
SocialWxJsapiSignatureRespDTO createWxMpJsapiSignature(Integer userType, String url);
//======================= 微信小程序独有 =======================
/**
* 获得微信小程序的手机信息
*
* @param userType 用户类型
* @param phoneCode 手机授权码
* @return 手机信息
*/
SocialWxPhoneNumberInfoRespDTO getWxMaPhoneNumberInfo(Integer userType, String phoneCode);
/**
* 获得小程序二维码
*
* @param reqVO 请求信息
* @return 小程序二维码
*/
byte[] getWxaQrcode(@Valid SocialWxQrcodeReqDTO reqVO);
/**
* 获得微信小程订阅模板
*
* @return 小程序订阅消息模版
*/
List<SocialWxaSubscribeTemplateRespDTO> getWxaSubscribeTemplateList(Integer userType);
/**
* 发送微信小程序订阅消息
*
* @param reqDTO 请求
*/
void sendWxaSubscribeMessage(SocialWxaSubscribeMessageSendReqDTO reqDTO);
}
package org.dromara.mall.api.service.system;
import jakarta.validation.Valid;
import org.dromara.mall.api.dto.member.SocialUserBindReqDTO;
import org.dromara.mall.api.dto.member.SocialUserRespDTO;
import org.dromara.mall.api.dto.member.SocialUserUnbindReqDTO;
/**
* 社交用户的 API 接口
*
* @author 芋道源码
*/
public interface SocialUserApi {
/**
* 绑定社交用户
*
* @param reqDTO 绑定信息
* @return 社交用户 openid
*/
String bindSocialUser(@Valid SocialUserBindReqDTO reqDTO);
/**
* 取消绑定社交用户
*
* @param reqDTO 解绑
*/
void unbindSocialUser(@Valid SocialUserUnbindReqDTO reqDTO);
/**
* 获得社交用户,基于 userId
*
* @param userType 用户类型
* @param userId 用户编号
* @param socialType 社交平台的类型
* @return 社交用户
*/
SocialUserRespDTO getSocialUserByUserId(Integer userType, Long userId, Integer socialType);
/**
* 获得社交用户
*
* 在认证信息不正确的情况下,也会抛出 {@link ServiceException} 业务异常
*
* @param userType 用户类型
* @param socialType 社交平台的类型
* @param code 授权码
* @param state state
* @return 社交用户
*/
SocialUserRespDTO getSocialUserByCode(Integer userType, Integer socialType, String code, String state);
}
package org.dromara.mall.api.service.system.impl;
import cn.hutool.core.collection.CollUtil;
import lombok.AllArgsConstructor;
import org.apache.dubbo.config.annotation.DubboReference;
import org.dromara.common.mall.enums.CommonStatusEnum;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.mall.api.dto.system.AdminUserRespDTO;
import org.dromara.mall.api.service.system.AdminUserApi;
import org.dromara.mall.convert.system.AdminUserConvert;
import org.dromara.system.api.RemoteUserService;
import org.dromara.system.api.domain.vo.RemoteUserVo;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.exception.util.ServiceExceptionUtil.exception;
import static org.dromara.mall.enums.member.ErrorCodeConstants.USER_NOT_EXISTS;
import static org.dromara.mall.enums.system.ErrorCodeConstants.USER_IS_DISABLE;
/**
* Admin 用户 API 实现类
*
* @author 芋道源码
*/
@Service
@AllArgsConstructor
public class AdminUserApiImpl implements AdminUserApi {
@DubboReference
private final RemoteUserService remoteUserService;
@Override
public AdminUserRespDTO getUser(Long id) {
if (id == null) {
return null;
}
List<RemoteUserVo> list = remoteUserService.selectUserVoListByUserIds(List.of(id));
return CollUtil.isEmpty(list) ? null : AdminUserConvert.INSTANCE.convert(list.get(0));
}
@Override
public List<AdminUserRespDTO> getUserList(Collection<Long> ids) {
List<RemoteUserVo> list = remoteUserService.selectUserVoListByUserIds((List<Long>) ids);
return AdminUserConvert.INSTANCE.convertList(list);
}
@Override
public void validateUserList(Collection<Long> ids) {
if (CollUtil.isEmpty(ids)) {
return;
}
List<RemoteUserVo> users = remoteUserService.selectUserVoListByUserIds((List<Long>) ids);
Map<Long, RemoteUserVo> userMap = CollectionUtils.convertMap(users, RemoteUserVo::getUserId);
// 校验
ids.forEach(id -> {
RemoteUserVo user = userMap.get(id);
if (user == null) {
throw exception(USER_NOT_EXISTS);
}
if (!CommonStatusEnum.ENABLE.getStatus().equals(Integer.parseInt(user.getStatus()))) {
throw exception(USER_IS_DISABLE, user.getNickName());
}
});
}
}
package org.dromara.mall.api.service.system.impl;
import org.dromara.mall.api.dto.system.NotifySendSingleToUserReqDTO;
import org.dromara.mall.api.service.system.NotifyMessageSendApi;
import org.springframework.stereotype.Service;
/**
* 站内信发送 API 实现类
*
* @author xrcoder
*/
@Service
public class NotifyMessageSendApiImpl implements NotifyMessageSendApi {
@Override
public Long sendSingleMessageToAdmin(NotifySendSingleToUserReqDTO reqDTO) {
return null;
}
@Override
public Long sendSingleMessageToMember(NotifySendSingleToUserReqDTO reqDTO) {
return null;
}
}
package org.dromara.mall.api.service.system.impl;
import lombok.extern.slf4j.Slf4j;
import org.dromara.mall.api.dto.member.SocialWxPhoneNumberInfoRespDTO;
import org.dromara.mall.api.dto.member.SocialWxQrcodeReqDTO;
import org.dromara.mall.api.dto.member.SocialWxaSubscribeMessageSendReqDTO;
import org.dromara.mall.api.dto.member.SocialWxaSubscribeTemplateRespDTO;
import org.dromara.mall.api.dto.system.SocialWxJsapiSignatureRespDTO;
import org.dromara.mall.api.service.system.SocialClientApi;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.List;
/**
* 社交应用的 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
@Slf4j
public class SocialClientApiImpl implements SocialClientApi {
@Override
public String getAuthorizeUrl(Integer socialType, Integer userType, String redirectUri) {
return null;
}
@Override
public SocialWxJsapiSignatureRespDTO createWxMpJsapiSignature(Integer userType, String url) {
return null;
}
@Override
public SocialWxPhoneNumberInfoRespDTO getWxMaPhoneNumberInfo(Integer userType, String phoneCode) {
return null;
}
@Override
public byte[] getWxaQrcode(SocialWxQrcodeReqDTO reqVO) {
return new byte[0];
}
@Override
public List<SocialWxaSubscribeTemplateRespDTO> getWxaSubscribeTemplateList(Integer userType) {
return null;
}
@Override
public void sendWxaSubscribeMessage(SocialWxaSubscribeMessageSendReqDTO reqDTO) {
}
}
package org.dromara.mall.api.service.system.impl;
import org.dromara.mall.api.dto.member.SocialUserBindReqDTO;
import org.dromara.mall.api.dto.member.SocialUserRespDTO;
import org.dromara.mall.api.dto.member.SocialUserUnbindReqDTO;
import org.dromara.mall.api.service.system.SocialUserApi;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
/**
* 社交用户的 API 实现类
*
* @author 芋道源码
*/
@Service
@Validated
public class SocialUserApiImpl implements SocialUserApi {
@Override
public String bindSocialUser(SocialUserBindReqDTO reqDTO) {
return null;
}
@Override
public void unbindSocialUser(SocialUserUnbindReqDTO reqDTO) {
}
@Override
public SocialUserRespDTO getSocialUserByUserId(Integer userType, Long userId, Integer socialType) {
return null;
}
@Override
public SocialUserRespDTO getSocialUserByCode(Integer userType, Integer socialType, String code, String state) {
return null;
}
}
package org.dromara.mall.api.service.trade;
import org.dromara.mall.api.dto.trade.TradeOrderRespDTO;
import java.util.Collection;
import java.util.List;
/**
* 订单 API 接口
*
* @author HUIHUI
*/
public interface TradeOrderApi {
/**
* 获得订单列表
*
* @param ids 订单编号数组
* @return 订单列表
*/
List<TradeOrderRespDTO> getOrderList(Collection<Long> ids);
/**
* 获得订单
*
* @param id 订单编号
* @return 订单
*/
TradeOrderRespDTO getOrder(Long id);
/**
* 取消支付订单
*
* @param userId 用户编号
* @param orderId 订单编号
* @param cancelType 取消类型
*/
void cancelPaidOrder(Long userId, Long orderId, Integer cancelType);
}
package org.dromara.mall.api.service.trade.impl;
import jakarta.annotation.Resource;
import org.dromara.mall.api.dto.trade.TradeOrderRespDTO;
import org.dromara.mall.api.service.trade.TradeOrderApi;
import org.dromara.mall.convert.trade.order.TradeOrderConvert;
import org.dromara.mall.service.trade.order.TradeOrderQueryService;
import org.dromara.mall.service.trade.order.TradeOrderUpdateService;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import java.util.Collection;
import java.util.List;
/**
* 订单 API 接口实现类
*
* @author HUIHUI
*/
@Service
@Validated
public class TradeOrderApiImpl implements TradeOrderApi {
@Resource
private TradeOrderUpdateService tradeOrderUpdateService;
@Resource
private TradeOrderQueryService tradeOrderQueryService;
@Override
public List<TradeOrderRespDTO> getOrderList(Collection<Long> ids) {
return TradeOrderConvert.INSTANCE.convertList04(tradeOrderQueryService.getOrderList(ids));
}
@Override
public TradeOrderRespDTO getOrder(Long id) {
return TradeOrderConvert.INSTANCE.convert(tradeOrderQueryService.getOrder(id));
}
@Override
public void cancelPaidOrder(Long userId, Long orderId, Integer cancelType) {
tradeOrderUpdateService.cancelPaidOrder(userId, orderId, cancelType);
}
}
package org.dromara.mall.convert.member;
import org.dromara.common.mall.util.ip.AreaUtils;
import org.dromara.mall.api.dto.member.MemberAddressRespDTO;
import org.dromara.mall.controller.member.admin.address.vo.AddressRespVO;
import org.dromara.mall.controller.member.app.address.vo.AppAddressCreateReqVO;
import org.dromara.mall.controller.member.app.address.vo.AppAddressRespVO;
import org.dromara.mall.controller.member.app.address.vo.AppAddressUpdateReqVO;
import org.dromara.mall.domain.member.MemberAddressDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Named;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 用户收件地址 Convert
*
* @author 芋道源码
*/
@Mapper
public interface AddressConvert {
AddressConvert INSTANCE = Mappers.getMapper(AddressConvert.class);
MemberAddressDO convert(AppAddressCreateReqVO bean);
MemberAddressDO convert(AppAddressUpdateReqVO bean);
@Mapping(source = "areaId", target = "areaName", qualifiedByName = "convertAreaIdToAreaName")
AppAddressRespVO convert(MemberAddressDO bean);
List<AppAddressRespVO> convertList(List<MemberAddressDO> list);
MemberAddressRespDTO convert02(MemberAddressDO bean);
@Named("convertAreaIdToAreaName")
default String convertAreaIdToAreaName(Integer areaId) {
return AreaUtils.format(areaId);
}
List<AddressRespVO> convertList2(List<MemberAddressDO> list);
}
package org.dromara.mall.convert.member;
import org.dromara.mall.api.dto.member.*;
import org.dromara.mall.controller.member.app.auth.vo.*;
import org.dromara.mall.controller.member.app.social.vo.AppSocialUserUnbindReqVO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface AuthConvert {
AuthConvert INSTANCE = Mappers.getMapper(AuthConvert.class);
SocialUserBindReqDTO convert(Long userId, Integer userType, AppAuthSocialLoginReqVO reqVO);
SocialUserUnbindReqDTO convert(Long userId, Integer userType, AppSocialUserUnbindReqVO reqVO);
SmsCodeSendReqDTO convert(AppAuthSmsSendReqVO reqVO);
// SmsCodeUseReqDTO convert(AppMemberUserResetPasswordReqVO reqVO, SmsSceneEnum scene, String usedIp);
SmsCodeUseReqDTO convert(AppAuthSmsLoginReqVO reqVO, Integer scene, String usedIp);
AppAuthLoginRespVO convert(OAuth2AccessTokenRespDTO bean, String openid);
SmsCodeValidateReqDTO convert(AppAuthSmsValidateReqVO bean);
SocialWxJsapiSignatureRespDTO convert(SocialWxJsapiSignatureRespDTO bean);
}
package org.dromara.mall.convert.member;
import org.dromara.mall.api.dto.member.MemberConfigRespDTO;
import org.dromara.mall.controller.member.admin.config.vo.MemberConfigRespVO;
import org.dromara.mall.controller.member.admin.config.vo.MemberConfigSaveReqVO;
import org.dromara.mall.domain.member.MemberConfigDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* 会员配置 Convert
*
* @author QingX
*/
@Mapper
public interface MemberConfigConvert {
MemberConfigConvert INSTANCE = Mappers.getMapper(MemberConfigConvert.class);
MemberConfigRespVO convert(MemberConfigDO bean);
MemberConfigDO convert(MemberConfigSaveReqVO bean);
MemberConfigRespDTO convert01(MemberConfigDO config);
}
package org.dromara.mall.convert.member;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.member.admin.level.vo.experience.MemberExperienceRecordRespVO;
import org.dromara.mall.controller.member.app.level.vo.experience.AppMemberExperienceRecordRespVO;
import org.dromara.mall.domain.member.MemberExperienceRecordDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 会员经验记录 Convert
*
* @author owen
*/
@Mapper
public interface MemberExperienceRecordConvert {
MemberExperienceRecordConvert INSTANCE = Mappers.getMapper(MemberExperienceRecordConvert.class);
MemberExperienceRecordRespVO convert(MemberExperienceRecordDO bean);
List<MemberExperienceRecordRespVO> convertList(List<MemberExperienceRecordDO> list);
PageResult<MemberExperienceRecordRespVO> convertPage(PageResult<MemberExperienceRecordDO> page);
MemberExperienceRecordDO convert(Long userId, Integer experience, Integer totalExperience,
String bizId, Integer bizType,
String title, String description);
PageResult<AppMemberExperienceRecordRespVO> convertPage02(PageResult<MemberExperienceRecordDO> page);
}
package org.dromara.mall.convert.member;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.member.admin.group.vo.MemberGroupCreateReqVO;
import org.dromara.mall.controller.member.admin.group.vo.MemberGroupRespVO;
import org.dromara.mall.controller.member.admin.group.vo.MemberGroupSimpleRespVO;
import org.dromara.mall.controller.member.admin.group.vo.MemberGroupUpdateReqVO;
import org.dromara.mall.domain.member.MemberGroupDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 用户分组 Convert
*
* @author owen
*/
@Mapper
public interface MemberGroupConvert {
MemberGroupConvert INSTANCE = Mappers.getMapper(MemberGroupConvert.class);
MemberGroupDO convert(MemberGroupCreateReqVO bean);
MemberGroupDO convert(MemberGroupUpdateReqVO bean);
MemberGroupRespVO convert(MemberGroupDO bean);
List<MemberGroupRespVO> convertList(List<MemberGroupDO> list);
PageResult<MemberGroupRespVO> convertPage(PageResult<MemberGroupDO> page);
List<MemberGroupSimpleRespVO> convertSimpleList(List<MemberGroupDO> list);
}
package org.dromara.mall.convert.member;
import org.dromara.mall.api.dto.member.MemberLevelRespDTO;
import org.dromara.mall.controller.member.admin.level.vo.level.MemberLevelCreateReqVO;
import org.dromara.mall.controller.member.admin.level.vo.level.MemberLevelRespVO;
import org.dromara.mall.controller.member.admin.level.vo.level.MemberLevelSimpleRespVO;
import org.dromara.mall.controller.member.admin.level.vo.level.MemberLevelUpdateReqVO;
import org.dromara.mall.controller.member.app.level.vo.level.AppMemberLevelRespVO;
import org.dromara.mall.domain.member.MemberLevelDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 会员等级 Convert
*
* @author owen
*/
@Mapper
public interface MemberLevelConvert {
MemberLevelConvert INSTANCE = Mappers.getMapper(MemberLevelConvert.class);
MemberLevelDO convert(MemberLevelCreateReqVO bean);
MemberLevelDO convert(MemberLevelUpdateReqVO bean);
MemberLevelRespVO convert(MemberLevelDO bean);
List<MemberLevelRespVO> convertList(List<MemberLevelDO> list);
List<MemberLevelSimpleRespVO> convertSimpleList(List<MemberLevelDO> list);
List<AppMemberLevelRespVO> convertList02(List<MemberLevelDO> list);
MemberLevelRespDTO convert02(MemberLevelDO bean);
}
package org.dromara.mall.convert.member;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.member.admin.level.vo.record.MemberLevelRecordRespVO;
import org.dromara.mall.domain.member.MemberLevelDO;
import org.dromara.mall.domain.member.MemberLevelRecordDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 会员等级记录 Convert
*
* @author owen
*/
@Mapper
public interface MemberLevelRecordConvert {
MemberLevelRecordConvert INSTANCE = Mappers.getMapper(MemberLevelRecordConvert.class);
MemberLevelRecordRespVO convert(MemberLevelRecordDO bean);
List<MemberLevelRecordRespVO> convertList(List<MemberLevelRecordDO> list);
PageResult<MemberLevelRecordRespVO> convertPage(PageResult<MemberLevelRecordDO> page);
default MemberLevelRecordDO copyTo(MemberLevelDO from, MemberLevelRecordDO to) {
if (from != null) {
to.setLevelId(from.getId());
to.setLevel(from.getLevel());
to.setDiscountPercent(from.getDiscountPercent());
to.setExperience(from.getExperience());
}
return to;
}
}
package org.dromara.mall.convert.member;
import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.member.admin.point.vo.recrod.MemberPointRecordRespVO;
import org.dromara.mall.domain.member.MemberPointRecordDO;
import org.dromara.mall.domain.member.MemberUserDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
/**
* 用户积分记录 Convert
*
* @author QingX
*/
@Mapper
public interface MemberPointRecordConvert {
MemberPointRecordConvert INSTANCE = Mappers.getMapper(MemberPointRecordConvert.class);
default PageResult<MemberPointRecordRespVO> convertPage(PageResult<MemberPointRecordDO> pageResult, List<MemberUserDO> users) {
PageResult<MemberPointRecordRespVO> voPageResult = convertPage(pageResult);
// user 拼接
Map<Long, MemberUserDO> userMap = convertMap(users, MemberUserDO::getId);
voPageResult.getList().forEach(record -> MapUtils.findAndThen(userMap, record.getUserId(),
memberUserRespDTO -> record.setNickname(memberUserRespDTO.getNickname())));
return voPageResult;
}
PageResult<MemberPointRecordRespVO> convertPage(PageResult<MemberPointRecordDO> pageResult);
}
package org.dromara.mall.convert.member;
import org.dromara.mall.controller.member.admin.signin.vo.config.MemberSignInConfigCreateReqVO;
import org.dromara.mall.controller.member.admin.signin.vo.config.MemberSignInConfigRespVO;
import org.dromara.mall.controller.member.admin.signin.vo.config.MemberSignInConfigUpdateReqVO;
import org.dromara.mall.controller.member.app.signin.vo.config.AppMemberSignInConfigRespVO;
import org.dromara.mall.domain.member.MemberSignInConfigDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 签到规则 Convert
*
* @author QingX
*/
@Mapper
public interface MemberSignInConfigConvert {
MemberSignInConfigConvert INSTANCE = Mappers.getMapper(MemberSignInConfigConvert.class);
MemberSignInConfigDO convert(MemberSignInConfigCreateReqVO bean);
MemberSignInConfigDO convert(MemberSignInConfigUpdateReqVO bean);
MemberSignInConfigRespVO convert(MemberSignInConfigDO bean);
List<MemberSignInConfigRespVO> convertList(List<MemberSignInConfigDO> list);
List<AppMemberSignInConfigRespVO> convertList02(List<MemberSignInConfigDO> list);
}
package org.dromara.mall.convert.member;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjUtil;import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mall.util.date.DateUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.member.admin.signin.vo.record.MemberSignInRecordRespVO;
import org.dromara.mall.controller.member.app.signin.vo.record.AppMemberSignInRecordRespVO;
import org.dromara.mall.domain.member.MemberSignInConfigDO;
import org.dromara.mall.domain.member.MemberSignInRecordDO;
import org.dromara.mall.domain.member.MemberUserDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.time.LocalDateTime;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
/**
* 签到记录 Convert
*
* @author 芋道源码
*/
@Mapper
public interface MemberSignInRecordConvert {
MemberSignInRecordConvert INSTANCE = Mappers.getMapper(MemberSignInRecordConvert.class);
default PageResult<MemberSignInRecordRespVO> convertPage(PageResult<MemberSignInRecordDO> pageResult, List<MemberUserDO> users) {
PageResult<MemberSignInRecordRespVO> voPageResult = convertPage(pageResult);
// user 拼接
Map<Long, MemberUserDO> userMap = convertMap(users, MemberUserDO::getId);
voPageResult.getList().forEach(record -> MapUtils.findAndThen(userMap, record.getUserId(),
memberUserRespDTO -> record.setNickname(memberUserRespDTO.getNickname())));
return voPageResult;
}
PageResult<MemberSignInRecordRespVO> convertPage(PageResult<MemberSignInRecordDO> pageResult);
PageResult<AppMemberSignInRecordRespVO> convertPage02(PageResult<MemberSignInRecordDO> pageResult);
AppMemberSignInRecordRespVO coverRecordToAppRecordVo(MemberSignInRecordDO memberSignInRecordDO);
default MemberSignInRecordDO convert(Long userId, MemberSignInRecordDO lastRecord, List<MemberSignInConfigDO> configs) {
// 1. 计算是第几天签到
configs.sort(Comparator.comparing(MemberSignInConfigDO::getDay));
MemberSignInConfigDO lastConfig = CollUtil.getLast(configs); // 最大签到天数配置
// 1.2. 计算今天是第几天签到 (只有连续签到才加否则重置为 1)
int day = 1;
if (lastRecord != null && DateUtils.isYesterday(LocalDateTime.from(lastRecord.getCreateTime().toInstant()))) {
day = lastRecord.getDay() + 1;
}
// 1.3 判断是否超出了最大签到配置
if (day > lastConfig.getDay()) {
day = 1; // 超过最大配置的天数,重置到第一天。(也就是说开启下一轮签到)
}
// 2.1 初始化签到信息
MemberSignInRecordDO record = new MemberSignInRecordDO().setUserId(userId)
.setDay(day).setPoint(0).setExperience(0);
// 2.2 获取签到对应的积分
MemberSignInConfigDO config = CollUtil.findOne(configs, item -> ObjUtil.equal(item.getDay(), record.getDay()));
if (config == null) {
return record;
}
record.setPoint(config.getPoint());
record.setExperience(config.getExperience());
return record;
}
}
package org.dromara.mall.convert.member;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.member.admin.tag.vo.MemberTagCreateReqVO;
import org.dromara.mall.controller.member.admin.tag.vo.MemberTagRespVO;
import org.dromara.mall.controller.member.admin.tag.vo.MemberTagUpdateReqVO;
import org.dromara.mall.domain.member.MemberTagDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 会员标签 Convert
*
* @author 芋道源码
*/
@Mapper
public interface MemberTagConvert {
MemberTagConvert INSTANCE = Mappers.getMapper(MemberTagConvert.class);
MemberTagDO convert(MemberTagCreateReqVO bean);
MemberTagDO convert(MemberTagUpdateReqVO bean);
MemberTagRespVO convert(MemberTagDO bean);
List<MemberTagRespVO> convertList(List<MemberTagDO> list);
PageResult<MemberTagRespVO> convertPage(PageResult<MemberTagDO> page);
}
package org.dromara.mall.convert.member;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.member.admin.user.vo.MemberUserRespVO;
import org.dromara.mall.controller.member.admin.user.vo.MemberUserUpdateReqVO;
import org.dromara.mall.controller.member.app.user.vo.AppMemberUserInfoRespVO;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.domain.member.MemberGroupDO;
import org.dromara.mall.domain.member.MemberLevelDO;
import org.dromara.mall.domain.member.MemberTagDO;
import org.dromara.mall.domain.member.MemberUserDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertList;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
@Mapper(uses = {AddressConvert.class})
public interface MemberUserConvert {
MemberUserConvert INSTANCE = Mappers.getMapper(MemberUserConvert.class);
AppMemberUserInfoRespVO convert(MemberUserDO bean);
@Mappings({
@Mapping(source = "level", target = "level"),
@Mapping(source = "bean.id", target = "id"),
@Mapping(source = "bean.experience", target = "experience")
})
AppMemberUserInfoRespVO convert(MemberUserDO bean, MemberLevelDO level);
MemberUserRespDTO convert2(MemberUserDO bean);
List<MemberUserRespDTO> convertList2(List<MemberUserDO> list);
MemberUserDO convert(MemberUserUpdateReqVO bean);
PageResult<MemberUserRespVO> convertPage(PageResult<MemberUserDO> page);
@Mapping(source = "areaId", target = "areaName", qualifiedByName = "convertAreaIdToAreaName")
MemberUserRespVO convert03(MemberUserDO bean);
default PageResult<MemberUserRespVO> convertPage(PageResult<MemberUserDO> pageResult,
List<MemberTagDO> tags,
List<MemberLevelDO> levels,
List<MemberGroupDO> groups) {
PageResult<MemberUserRespVO> result = convertPage(pageResult);
// 处理关联数据
Map<Long, String> tagMap = convertMap(tags, MemberTagDO::getId, MemberTagDO::getName);
Map<Long, String> levelMap = convertMap(levels, MemberLevelDO::getId, MemberLevelDO::getName);
Map<Long, String> groupMap = convertMap(groups, MemberGroupDO::getId, MemberGroupDO::getName);
// 填充关联数据
result.getList().forEach(user -> {
user.setTagNames(convertList(user.getTagIds(), tagMap::get));
user.setLevelName(levelMap.get(user.getLevelId()));
user.setGroupName(groupMap.get(user.getGroupId()));
});
return result;
}
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.app.vo.PayAppCreateReqVO;
import org.dromara.mall.controller.pay.admin.app.vo.PayAppPageItemRespVO;
import org.dromara.mall.controller.pay.admin.app.vo.PayAppRespVO;
import org.dromara.mall.controller.pay.admin.app.vo.PayAppUpdateReqVO;
import org.dromara.mall.domain.pay.PayAppDO;
import org.dromara.mall.domain.pay.PayChannelDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 支付应用信息 Convert
*
* @author 芋艿
*/
@Mapper
public interface PayAppConvert {
PayAppConvert INSTANCE = Mappers.getMapper(PayAppConvert.class);
PayAppPageItemRespVO pageConvert (PayAppDO bean);
PayAppDO convert(PayAppCreateReqVO bean);
PayAppDO convert(PayAppUpdateReqVO bean);
PayAppRespVO convert(PayAppDO bean);
List<PayAppRespVO> convertList(List<PayAppDO> list);
PageResult<PayAppPageItemRespVO> convertPage(PageResult<PayAppDO> page);
default PageResult<PayAppPageItemRespVO> convertPage(PageResult<PayAppDO> pageResult, List<PayChannelDO> channels) {
PageResult<PayAppPageItemRespVO> voPageResult = convertPage(pageResult);
// 处理 channel 关系
Map<Long, Set<String>> appIdChannelMap = CollectionUtils.convertMultiMap2(channels, PayChannelDO::getAppId, PayChannelDO::getCode);
voPageResult.getList().forEach(app -> app.setChannelCodes(appIdChannelMap.get(app.getId())));
return voPageResult;
}
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.channel.vo.PayChannelCreateReqVO;
import org.dromara.mall.controller.pay.admin.channel.vo.PayChannelRespVO;
import org.dromara.mall.controller.pay.admin.channel.vo.PayChannelUpdateReqVO;
import org.dromara.mall.domain.pay.PayChannelDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
@Mapper
public interface PayChannelConvert {
PayChannelConvert INSTANCE = Mappers.getMapper(PayChannelConvert.class);
@Mapping(target = "config",ignore = true)
PayChannelDO convert(PayChannelCreateReqVO bean);
@Mapping(target = "config",ignore = true)
PayChannelDO convert(PayChannelUpdateReqVO bean);
@Mapping(target = "config",expression = "java(org.dromara.common.json.utils.JsonUtils.toJsonString(bean.getConfig()))")
PayChannelRespVO convert(PayChannelDO bean);
PageResult<PayChannelRespVO> convertPage(PageResult<PayChannelDO> page);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.demo.vo.order.PayDemoOrderCreateReqVO;
import org.dromara.mall.controller.pay.admin.demo.vo.order.PayDemoOrderRespVO;
import org.dromara.mall.domain.pay.PayDemoOrderDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
/**
* 示例订单 Convert
*
* @author 芋道源码
*/
@Mapper
public interface PayDemoOrderConvert {
PayDemoOrderConvert INSTANCE = Mappers.getMapper(PayDemoOrderConvert.class);
PayDemoOrderDO convert(PayDemoOrderCreateReqVO bean);
@Mapping(target = "createTime", expression = "java(org.dromara.common.mall.util.date.DateUtils.of(bean.getCreateTime()))")
PayDemoOrderRespVO convert(PayDemoOrderDO bean);
PageResult<PayDemoOrderRespVO> convertPage(PageResult<PayDemoOrderDO> page);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.demo.vo.transfer.PayDemoTransferCreateReqVO;
import org.dromara.mall.controller.pay.admin.demo.vo.transfer.PayDemoTransferRespVO;
import org.dromara.mall.domain.pay.PayDemoTransferDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* @author jason
*/
@Mapper
public interface PayDemoTransferConvert {
PayDemoTransferConvert INSTANCE = Mappers.getMapper(PayDemoTransferConvert.class);
PayDemoTransferDO convert(PayDemoTransferCreateReqVO bean);
PageResult<PayDemoTransferRespVO> convertPage(PageResult<PayDemoTransferDO> pageResult);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.notify.vo.PayNotifyTaskDetailRespVO;
import org.dromara.mall.controller.pay.admin.notify.vo.PayNotifyTaskRespVO;
import org.dromara.mall.domain.pay.PayAppDO;
import org.dromara.mall.domain.pay.PayNotifyLogDO;
import org.dromara.mall.domain.pay.PayNotifyTaskDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
/**
* 支付通知 Convert
*
* @author 芋道源码
*/
@Mapper
public interface PayNotifyTaskConvert {
PayNotifyTaskConvert INSTANCE = Mappers.getMapper(PayNotifyTaskConvert.class);
PayNotifyTaskRespVO convert(PayNotifyTaskDO bean);
default PageResult<PayNotifyTaskRespVO> convertPage(PageResult<PayNotifyTaskDO> page, Map<Long, PayAppDO> appMap){
PageResult<PayNotifyTaskRespVO> result = convertPage(page);
result.getList().forEach(order -> MapUtils.findAndThen(appMap, order.getAppId(), app -> order.setAppName(app.getName())));
return result;
}
PageResult<PayNotifyTaskRespVO> convertPage(PageResult<PayNotifyTaskDO> page);
default PayNotifyTaskDetailRespVO convert(PayNotifyTaskDO task, PayAppDO app, List<PayNotifyLogDO> logs) {
PayNotifyTaskDetailRespVO respVO = convert(task, logs);
if (app != null) {
respVO.setAppName(app.getName());
}
return respVO;
}
PayNotifyTaskDetailRespVO convert(PayNotifyTaskDO task, List<PayNotifyLogDO> logs);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.common.pay.core.client.dto.order.PayOrderUnifiedReqDTO;
import org.dromara.mall.api.dto.pay.PayOrderCreateReqDTO;
import org.dromara.mall.api.dto.pay.PayOrderRespDTO;
import org.dromara.mall.controller.pay.admin.order.vo.*;
import org.dromara.mall.controller.pay.app.order.vo.AppPayOrderSubmitRespVO;
import org.dromara.mall.domain.pay.PayAppDO;
import org.dromara.mall.domain.pay.PayOrderDO;
import org.dromara.mall.domain.pay.PayOrderExtensionDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
/**
* 支付订单 Convert
*
* @author aquan
*/
@Mapper
public interface PayOrderConvert {
PayOrderConvert INSTANCE = Mappers.getMapper(PayOrderConvert.class);
@Mapping(target = "createTime", expression = "java(org.dromara.common.mall.util.date.DateUtils.of(bean.getCreateTime()))")
PayOrderRespVO convert(PayOrderDO bean);
PayOrderRespDTO convert2(PayOrderDO order);
default PayOrderDetailsRespVO convert(PayOrderDO order, PayOrderExtensionDO orderExtension, PayAppDO app) {
PayOrderDetailsRespVO respVO = convertDetail(order);
respVO.setExtension(convert(orderExtension));
if (app != null) {
respVO.setAppName(app.getName());
}
return respVO;
}
@Mapping(target = "createTime", expression = "java(org.dromara.common.mall.util.date.DateUtils.of(bean.getCreateTime()))")
@Mapping(target = "updateTime", expression = "java(org.dromara.common.mall.util.date.DateUtils.of(bean.getUpdateTime()))")
PayOrderDetailsRespVO convertDetail(PayOrderDO bean);
PayOrderDetailsRespVO.PayOrderExtension convert(PayOrderExtensionDO bean);
default PageResult<PayOrderPageItemRespVO> convertPage(PageResult<PayOrderDO> page, Map<Long, PayAppDO> appMap) {
PageResult<PayOrderPageItemRespVO> result = convertPage(page);
result.getList().forEach(order -> MapUtils.findAndThen(appMap, order.getAppId(), app -> order.setAppName(app.getName())));
return result;
}
PageResult<PayOrderPageItemRespVO> convertPage(PageResult<PayOrderDO> page);
@Mapping(target = "createTime", expression = "java(org.dromara.common.mall.util.date.DateUtils.of(bean.getCreateTime()))")
PayOrderPageItemRespVO convert3(PayOrderDO bean);
default List<PayOrderExcelVO> convertList(List<PayOrderDO> list, Map<Long, PayAppDO> appMap) {
return CollectionUtils.convertList(list, order -> {
PayOrderExcelVO excelVO = convertExcel(order);
MapUtils.findAndThen(appMap, order.getAppId(), app -> excelVO.setAppName(app.getName()));
return excelVO;
});
}
PayOrderExcelVO convertExcel(PayOrderDO bean);
PayOrderDO convert(PayOrderCreateReqDTO bean);
@Mapping(target = "id", ignore = true)
PayOrderExtensionDO convert(PayOrderSubmitReqVO bean, String userIp);
PayOrderUnifiedReqDTO convert2(PayOrderSubmitReqVO reqVO, String userIp);
@Mapping(source = "order.status", target = "status")
PayOrderSubmitRespVO convert(PayOrderDO order, org.dromara.common.pay.core.client.dto.order.PayOrderRespDTO respDTO);
AppPayOrderSubmitRespVO convert3(PayOrderSubmitRespVO bean);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.pay.PayRefundCreateReqDTO;
import org.dromara.mall.api.dto.pay.PayRefundRespDTO;
import org.dromara.mall.controller.pay.admin.refund.vo.PayRefundDetailsRespVO;
import org.dromara.mall.controller.pay.admin.refund.vo.PayRefundExcelVO;
import org.dromara.mall.controller.pay.admin.refund.vo.PayRefundPageItemRespVO;
import org.dromara.mall.domain.pay.PayAppDO;
import org.dromara.mall.domain.pay.PayOrderDO;
import org.dromara.mall.domain.pay.PayRefundDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
@Mapper
public interface PayRefundConvert {
PayRefundConvert INSTANCE = Mappers.getMapper(PayRefundConvert.class);
default PayRefundDetailsRespVO convert(PayRefundDO refund, PayAppDO app) {
PayRefundDetailsRespVO respVO = convert(refund);
if (app != null) {
respVO.setAppName(app.getName());
}
return respVO;
}
PayRefundDetailsRespVO convert(PayRefundDO bean);
PayRefundDetailsRespVO.Order convert(PayOrderDO bean);
default PageResult<PayRefundPageItemRespVO> convertPage(PageResult<PayRefundDO> page, Map<Long, PayAppDO> appMap) {
PageResult<PayRefundPageItemRespVO> result = convertPage(page);
result.getList().forEach(order -> MapUtils.findAndThen(appMap, order.getAppId(), app -> order.setAppName(app.getName())));
return result;
}
PageResult<PayRefundPageItemRespVO> convertPage(PageResult<PayRefundDO> page);
PayRefundDO convert(PayRefundCreateReqDTO bean);
PayRefundRespDTO convert02(PayRefundDO bean);
default List<PayRefundExcelVO> convertList(List<PayRefundDO> list, Map<Long, PayAppDO> appMap) {
return CollectionUtils.convertList(list, order -> {
PayRefundExcelVO excelVO = convertExcel(order);
MapUtils.findAndThen(appMap, order.getAppId(), app -> excelVO.setAppName(app.getName()));
return excelVO;
});
}
PayRefundExcelVO convertExcel(PayRefundDO bean);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.common.pay.core.client.dto.transfer.PayTransferUnifiedReqDTO;
import org.dromara.mall.api.dto.pay.PayTransferCreateReqDTO;
import org.dromara.mall.controller.pay.admin.demo.vo.transfer.PayDemoTransferCreateReqVO;
import org.dromara.mall.controller.pay.admin.transfer.vo.PayTransferCreateReqVO;
import org.dromara.mall.controller.pay.admin.transfer.vo.PayTransferPageItemRespVO;
import org.dromara.mall.controller.pay.admin.transfer.vo.PayTransferRespVO;
import org.dromara.mall.domain.pay.PayTransferDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface PayTransferConvert {
PayTransferConvert INSTANCE = Mappers.getMapper(PayTransferConvert.class);
PayTransferDO convert(PayTransferCreateReqDTO dto);
PayTransferUnifiedReqDTO convert2(PayTransferDO dto);
PayTransferCreateReqDTO convert(PayTransferCreateReqVO vo);
PayTransferCreateReqDTO convert(PayDemoTransferCreateReqVO vo);
PayTransferRespVO convert(PayTransferDO bean);
PageResult<PayTransferPageItemRespVO> convertPage(PageResult<PayTransferDO> pageResult);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.wallet.vo.wallet.PayWalletRespVO;
import org.dromara.mall.controller.pay.app.wallet.vo.wallet.AppPayWalletRespVO;
import org.dromara.mall.domain.pay.PayWalletDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface PayWalletConvert {
PayWalletConvert INSTANCE = Mappers.getMapper(PayWalletConvert.class);
AppPayWalletRespVO convert(PayWalletDO bean);
PayWalletRespVO convert02(PayWalletDO bean);
PageResult<PayWalletRespVO> convertPage(PageResult<PayWalletDO> page);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.dict.utils.DictUtils;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.controller.pay.app.wallet.vo.recharge.AppPayWalletRechargeCreateRespVO;
import org.dromara.mall.controller.pay.app.wallet.vo.recharge.AppPayWalletRechargeRespVO;
import org.dromara.mall.domain.pay.PayOrderDO;
import org.dromara.mall.domain.pay.PayWalletRechargeDO;
import org.dromara.mall.enums.pay.DictTypeConstants;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
@Mapper
public interface PayWalletRechargeConvert {
PayWalletRechargeConvert INSTANCE = Mappers.getMapper(PayWalletRechargeConvert.class);
@Mapping(target = "totalPrice", expression = "java( payPrice + bonusPrice)")
PayWalletRechargeDO convert(Long walletId, Integer payPrice, Integer bonusPrice, Long packageId);
AppPayWalletRechargeCreateRespVO convert(PayWalletRechargeDO bean);
default PageResult<AppPayWalletRechargeRespVO> convertPage(PageResult<PayWalletRechargeDO> pageResult,
List<PayOrderDO> payOrderList) {
PageResult<AppPayWalletRechargeRespVO> voPageResult = BeanUtils.toBean(pageResult, AppPayWalletRechargeRespVO.class);
Map<Long, PayOrderDO> payOrderMap = CollectionUtils.convertMap(payOrderList, PayOrderDO::getId);
voPageResult.getList().forEach(recharge -> {
recharge.setPayChannelName(DictUtils.getDictDataLabel(
DictTypeConstants.CHANNEL_CODE, recharge.getPayChannelCode()));
MapUtils.findAndThen(payOrderMap, recharge.getPayOrderId(),
order -> recharge.setPayOrderChannelOrderNo(order.getChannelOrderNo()));
});
return voPageResult;
}
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.wallet.vo.rechargepackage.WalletRechargePackageCreateReqVO;
import org.dromara.mall.controller.pay.admin.wallet.vo.rechargepackage.WalletRechargePackageRespVO;
import org.dromara.mall.controller.pay.admin.wallet.vo.rechargepackage.WalletRechargePackageUpdateReqVO;
import org.dromara.mall.domain.pay.PayWalletRechargePackageDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public interface PayWalletRechargePackageConvert {
PayWalletRechargePackageConvert INSTANCE = Mappers.getMapper(PayWalletRechargePackageConvert.class);
PayWalletRechargePackageDO convert(WalletRechargePackageCreateReqVO bean);
PayWalletRechargePackageDO convert(WalletRechargePackageUpdateReqVO bean);
WalletRechargePackageRespVO convert(PayWalletRechargePackageDO bean);
List<WalletRechargePackageRespVO> convertList(List<PayWalletRechargePackageDO> list);
PageResult<WalletRechargePackageRespVO> convertPage(PageResult<PayWalletRechargePackageDO> page);
}
package org.dromara.mall.convert.pay;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.pay.admin.wallet.vo.transaction.PayWalletTransactionRespVO;
import org.dromara.mall.domain.pay.PayWalletTransactionDO;
import org.dromara.mall.service.pay.bo.WalletTransactionCreateReqBO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface PayWalletTransactionConvert {
PayWalletTransactionConvert INSTANCE = Mappers.getMapper(PayWalletTransactionConvert.class);
PageResult<PayWalletTransactionRespVO> convertPage2(PageResult<PayWalletTransactionDO> page);
PayWalletTransactionDO convert(WalletTransactionCreateReqBO bean);
}
package org.dromara.mall.convert.product;
import org.dromara.common.mall.util.object.BeanUtils;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.api.dto.product.ProductCommentCreateReqDTO;
import org.dromara.mall.controller.product.admin.comment.vo.ProductCommentCreateReqVO;
import org.dromara.mall.domain.product.ProductCommentDO;
import org.dromara.mall.domain.product.ProductSkuDO;
import org.dromara.mall.domain.product.ProductSpuDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* 商品评价 Convert
*
* @author wangzhs
*/
@Mapper
public interface ProductCommentConvert {
ProductCommentConvert INSTANCE = Mappers.getMapper(ProductCommentConvert.class);
default ProductCommentDO convert(ProductCommentCreateReqDTO createReqDTO,
ProductSpuDO spu, ProductSkuDO sku, MemberUserRespDTO user) {
ProductCommentDO comment = BeanUtils.toBean(createReqDTO, ProductCommentDO.class)
.setScores(convertScores(createReqDTO.getDescriptionScores(), createReqDTO.getBenefitScores()));
if (user != null) {
comment.setUserId(user.getId()).setUserNickname(user.getNickname()).setUserAvatar(user.getAvatar());
}
if (spu != null) {
comment.setSpuId(spu.getId()).setSpuName(spu.getName());
}
if (sku != null) {
comment.setSkuPicUrl(sku.getPicUrl()).setSkuProperties(sku.getProperties());
}
return comment;
}
default ProductCommentDO convert(ProductCommentCreateReqVO createReq, ProductSpuDO spu, ProductSkuDO sku) {
ProductCommentDO comment = BeanUtils.toBean(createReq, ProductCommentDO.class)
.setVisible(true).setUserId(0L).setAnonymous(false)
.setScores(convertScores(createReq.getDescriptionScores(), createReq.getBenefitScores()));
if (spu != null) {
comment.setSpuId(spu.getId()).setSpuName(spu.getName());
}
if (sku != null) {
comment.setSkuPicUrl(sku.getPicUrl()).setSkuProperties(sku.getProperties());
}
return comment;
}
default Integer convertScores(Integer descriptionScores, Integer benefitScores) {
// 计算评价最终综合评分 最终星数 = (商品评星 + 服务评星) / 2
BigDecimal sumScore = new BigDecimal(descriptionScores + benefitScores);
BigDecimal divide = sumScore.divide(BigDecimal.valueOf(2L), 0, RoundingMode.DOWN);
return divide.intValue();
}
}
package org.dromara.mall.convert.product;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.product.admin.favorite.vo.ProductFavoriteRespVO;
import org.dromara.mall.controller.product.app.favorite.vo.AppFavoriteRespVO;
import org.dromara.mall.domain.product.ProductFavoriteDO;
import org.dromara.mall.domain.product.ProductSpuDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
@Mapper
public interface ProductFavoriteConvert {
ProductFavoriteConvert INSTANCE = Mappers.getMapper(ProductFavoriteConvert.class);
ProductFavoriteDO convert(Long userId, Long spuId);
@Mapping(target = "id", source = "favorite.id")
@Mapping(target = "spuName", source = "spu.name")
AppFavoriteRespVO convert(ProductSpuDO spu, ProductFavoriteDO favorite);
default List<AppFavoriteRespVO> convertList(List<ProductFavoriteDO> favorites, List<ProductSpuDO> spus) {
List<AppFavoriteRespVO> resultList = new ArrayList<>(favorites.size());
Map<Long, ProductSpuDO> spuMap = convertMap(spus, ProductSpuDO::getId);
for (ProductFavoriteDO favorite : favorites) {
ProductSpuDO spuDO = spuMap.get(favorite.getSpuId());
resultList.add(convert(spuDO, favorite));
}
return resultList;
}
default PageResult<ProductFavoriteRespVO> convertPage(PageResult<ProductFavoriteDO> pageResult, List<ProductSpuDO> spuList) {
Map<Long, ProductSpuDO> spuMap = convertMap(spuList, ProductSpuDO::getId);
List<ProductFavoriteRespVO> voList = CollectionUtils.convertList(pageResult.getList(), favorite -> {
ProductSpuDO spu = spuMap.get(favorite.getSpuId());
return convert02(spu, favorite);
});
return new PageResult<>(voList, pageResult.getTotal());
}
@Mapping(target = "id", source = "favorite.id")
@Mapping(target = "userId", source = "favorite.userId")
@Mapping(target = "spuId", source = "favorite.spuId")
@Mapping(target = "createTime", source = "favorite.createTime")
ProductFavoriteRespVO convert02(ProductSpuDO spu, ProductFavoriteDO favorite);
}
package org.dromara.mall.convert.product;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import org.dromara.mall.api.dto.product.ProductSkuUpdateStockReqDTO;
import org.dromara.mall.domain.product.ProductSkuDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.*;
import java.util.stream.Collectors;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
/**
* 商品 SKU Convert
*
* @author 芋道源码
*/
@Mapper
public interface ProductSkuConvert {
ProductSkuConvert INSTANCE = Mappers.getMapper(ProductSkuConvert.class);
/**
* 获得 SPU 的库存变化 Map
*
* @param items SKU 库存变化
* @param skus SKU 列表
* @return SPU 的库存变化 Map
*/
default Map<Long, Integer> convertSpuStockMap(List<ProductSkuUpdateStockReqDTO.Item> items,
List<ProductSkuDO> skus) {
Map<Long, Long> skuIdAndSpuIdMap = convertMap(skus, ProductSkuDO::getId, ProductSkuDO::getSpuId); // SKU 与 SKU 编号的 Map 关系
Map<Long, Integer> spuIdAndStockMap = new HashMap<>(); // SPU 的库存变化 Map 关系
items.forEach(item -> {
Long spuId = skuIdAndSpuIdMap.get(item.getId());
if (spuId == null) {
return;
}
Integer stock = spuIdAndStockMap.getOrDefault(spuId, 0) + item.getIncrCount();
spuIdAndStockMap.put(spuId, stock);
});
return spuIdAndStockMap;
}
default String buildPropertyKey(ProductSkuDO bean) {
if (CollUtil.isEmpty(bean.getProperties())) {
return StrUtil.EMPTY;
}
List<ProductSkuDO.Property> properties = new ArrayList<>(bean.getProperties());
properties.sort(Comparator.comparing(ProductSkuDO.Property::getValueId));
return properties.stream().map(m -> String.valueOf(m.getValueId())).collect(Collectors.joining());
}
}
package org.dromara.mall.convert.product;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mall.util.object.BeanUtils;
import org.dromara.mall.controller.product.admin.spu.vo.ProductSkuRespVO;
import org.dromara.mall.controller.product.admin.spu.vo.ProductSpuPageReqVO;
import org.dromara.mall.controller.product.admin.spu.vo.ProductSpuRespVO;
import org.dromara.mall.controller.product.app.spu.vo.AppProductSpuPageReqVO;
import org.dromara.mall.domain.product.ProductSkuDO;
import org.dromara.mall.domain.product.ProductSpuDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMultiMap;
/**
* 商品 SPU Convert
*
* @author 芋道源码
*/
@Mapper
public interface ProductSpuConvert {
ProductSpuConvert INSTANCE = Mappers.getMapper(ProductSpuConvert.class);
ProductSpuPageReqVO convert(AppProductSpuPageReqVO bean);
default ProductSpuRespVO convert(ProductSpuDO spu, List<ProductSkuDO> skus) {
ProductSpuRespVO spuVO = BeanUtils.toBean(spu, ProductSpuRespVO.class);
spuVO.setSkus(BeanUtils.toBean(skus, ProductSkuRespVO.class));
return spuVO;
}
default List<ProductSpuRespVO> convertForSpuDetailRespListVO(List<ProductSpuDO> spus, List<ProductSkuDO> skus) {
Map<Long, List<ProductSkuDO>> skuMultiMap = convertMultiMap(skus, ProductSkuDO::getSpuId);
return CollectionUtils.convertList(spus, spu -> convert(spu, skuMultiMap.get(spu.getId())));
}
}
package org.dromara.mall.convert.promotion.article;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.promotion.admin.article.vo.category.ArticleCategoryCreateReqVO;
import org.dromara.mall.controller.promotion.admin.article.vo.category.ArticleCategoryRespVO;
import org.dromara.mall.controller.promotion.admin.article.vo.category.ArticleCategorySimpleRespVO;
import org.dromara.mall.controller.promotion.admin.article.vo.category.ArticleCategoryUpdateReqVO;
import org.dromara.mall.controller.promotion.app.article.vo.category.AppArticleCategoryRespVO;
import org.dromara.mall.domain.promotion.ArticleCategoryDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 文章分类 Convert
*
* @author HUIHUI
*/
@Mapper
public interface ArticleCategoryConvert {
ArticleCategoryConvert INSTANCE = Mappers.getMapper(ArticleCategoryConvert.class);
ArticleCategoryDO convert(ArticleCategoryCreateReqVO bean);
ArticleCategoryDO convert(ArticleCategoryUpdateReqVO bean);
ArticleCategoryRespVO convert(ArticleCategoryDO bean);
List<ArticleCategoryRespVO> convertList(List<ArticleCategoryDO> list);
PageResult<ArticleCategoryRespVO> convertPage(PageResult<ArticleCategoryDO> page);
List<ArticleCategorySimpleRespVO> convertList03(List<ArticleCategoryDO> list);
List<AppArticleCategoryRespVO> convertList04(List<ArticleCategoryDO> categoryList);
}
package org.dromara.mall.convert.promotion.article;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.promotion.admin.article.vo.article.ArticleCreateReqVO;
import org.dromara.mall.controller.promotion.admin.article.vo.article.ArticleRespVO;
import org.dromara.mall.controller.promotion.admin.article.vo.article.ArticleUpdateReqVO;
import org.dromara.mall.controller.promotion.app.article.vo.article.AppArticleRespVO;
import org.dromara.mall.domain.promotion.ArticleDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 文章管理 Convert
*
* @author HUIHUI
*/
@Mapper
public interface ArticleConvert {
ArticleConvert INSTANCE = Mappers.getMapper(ArticleConvert.class);
ArticleDO convert(ArticleCreateReqVO bean);
ArticleDO convert(ArticleUpdateReqVO bean);
ArticleRespVO convert(ArticleDO bean);
List<ArticleRespVO> convertList(List<ArticleDO> list);
PageResult<ArticleRespVO> convertPage(PageResult<ArticleDO> page);
AppArticleRespVO convert01(ArticleDO article);
PageResult<AppArticleRespVO> convertPage02(PageResult<ArticleDO> articlePage);
List<AppArticleRespVO> convertList03(List<ArticleDO> articleCategoryListByRecommendHotAndRecommendBanner);
}
package org.dromara.mall.convert.promotion.banner;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.promotion.admin.banner.vo.BannerCreateReqVO;
import org.dromara.mall.controller.promotion.admin.banner.vo.BannerRespVO;
import org.dromara.mall.controller.promotion.admin.banner.vo.BannerUpdateReqVO;
import org.dromara.mall.controller.promotion.app.banner.vo.AppBannerRespVO;
import org.dromara.mall.domain.promotion.BannerDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public interface BannerConvert {
BannerConvert INSTANCE = Mappers.getMapper(BannerConvert.class);
List<BannerRespVO> convertList(List<BannerDO> list);
PageResult<BannerRespVO> convertPage(PageResult<BannerDO> pageResult);
BannerRespVO convert(BannerDO banner);
BannerDO convert(BannerCreateReqVO createReqVO);
BannerDO convert(BannerUpdateReqVO updateReqVO);
List<AppBannerRespVO> convertList01(List<BannerDO> bannerList);
}
package org.dromara.mall.convert.promotion.bargain;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.product.ProductSpuRespDTO;
import org.dromara.mall.controller.promotion.admin.bargain.vo.activity.BargainActivityBaseVO;
import org.dromara.mall.controller.promotion.admin.bargain.vo.activity.BargainActivityPageItemRespVO;
import org.dromara.mall.controller.promotion.admin.bargain.vo.activity.BargainActivityRespVO;
import org.dromara.mall.controller.promotion.admin.bargain.vo.activity.BargainActivityUpdateReqVO;
import org.dromara.mall.controller.promotion.app.bargain.vo.activity.AppBargainActivityDetailRespVO;
import org.dromara.mall.controller.promotion.app.bargain.vo.activity.AppBargainActivityRespVO;
import org.dromara.mall.domain.promotion.BargainActivityDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
import static org.dromara.common.mall.util.collection.MapUtils.findAndThen;
/**
* 拼团活动 Convert
*
* @author HUIHUI
*/
@Mapper
public interface BargainActivityConvert {
BargainActivityConvert INSTANCE = Mappers.getMapper(BargainActivityConvert.class);
BargainActivityDO convert(BargainActivityBaseVO bean);
BargainActivityDO convert(BargainActivityUpdateReqVO bean);
BargainActivityRespVO convert(BargainActivityDO bean);
List<BargainActivityRespVO> convertList(List<BargainActivityDO> list);
PageResult<BargainActivityPageItemRespVO> convertPage(PageResult<BargainActivityDO> page);
default PageResult<BargainActivityPageItemRespVO> convertPage(PageResult<BargainActivityDO> page, List<ProductSpuRespDTO> spuList,
Map<Long, Integer> recordUserCountMap, Map<Long, Integer> recordSuccessUserCountMap,
Map<Long, Integer> helpUserCountMap) {
PageResult<BargainActivityPageItemRespVO> result = convertPage(page);
// 拼接关联属性
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
result.getList().forEach(item -> {
findAndThen(spuMap, item.getSpuId(), spu -> {
item.setPicUrl(spu.getPicUrl()).setSpuName(spu.getName());
});
// 设置统计字段
item.setRecordUserCount(recordUserCountMap.getOrDefault(item.getId(), 0))
.setRecordSuccessUserCount(recordSuccessUserCountMap.getOrDefault(item.getId(), 0))
.setHelpUserCount(helpUserCountMap.getOrDefault(item.getId(), 0));
});
return result;
}
AppBargainActivityDetailRespVO convert1(BargainActivityDO bean);
default AppBargainActivityDetailRespVO convert(BargainActivityDO bean, Integer successUserCount, ProductSpuRespDTO spu) {
AppBargainActivityDetailRespVO detail = convert1(bean).setSuccessUserCount(successUserCount);
if (spu != null) {
detail.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice());
}
return detail;
}
PageResult<AppBargainActivityRespVO> convertAppPage(PageResult<BargainActivityDO> page);
default PageResult<AppBargainActivityRespVO> convertAppPage(PageResult<BargainActivityDO> page, List<ProductSpuRespDTO> spuList) {
PageResult<AppBargainActivityRespVO> result = convertAppPage(page);
// 拼接关联属性
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
List<AppBargainActivityRespVO> list = CollectionUtils.convertList(result.getList(), item -> {
findAndThen(spuMap, item.getSpuId(), spu -> item.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
});
result.setList(list);
return result;
}
List<AppBargainActivityRespVO> convertAppList(List<BargainActivityDO> list);
default List<AppBargainActivityRespVO> convertAppList(List<BargainActivityDO> list, List<ProductSpuRespDTO> spuList) {
List<AppBargainActivityRespVO> activityList = convertAppList(list);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
return CollectionUtils.convertList(activityList, item -> {
findAndThen(spuMap, item.getSpuId(), spu -> item.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
});
}
}
package org.dromara.mall.convert.promotion.bargain;
import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.controller.promotion.admin.bargain.vo.help.BargainHelpRespVO;
import org.dromara.mall.controller.promotion.app.bargain.vo.help.AppBargainHelpRespVO;
import org.dromara.mall.domain.promotion.BargainHelpDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
/**
* 砍价助力 Convert
*
* @author 芋道源码
*/
@Mapper
public interface BargainHelpConvert {
BargainHelpConvert INSTANCE = Mappers.getMapper(BargainHelpConvert.class);
default PageResult<BargainHelpRespVO> convertPage(PageResult<BargainHelpDO> page,
Map<Long, MemberUserRespDTO> userMap) {
PageResult<BargainHelpRespVO> pageResult = convertPage(page);
// 拼接数据
pageResult.getList().forEach(record ->
MapUtils.findAndThen(userMap, record.getUserId(),
user -> record.setNickname(user.getNickname()).setAvatar(user.getAvatar())));
return pageResult;
}
PageResult<BargainHelpRespVO> convertPage(PageResult<BargainHelpDO> page);
default List<AppBargainHelpRespVO> convertList(List<BargainHelpDO> helps,
Map<Long, MemberUserRespDTO> userMap) {
List<AppBargainHelpRespVO> helpVOs = convertList02(helps);
helpVOs.forEach(help ->
MapUtils.findAndThen(userMap, help.getUserId(),
user -> help.setNickname(user.getNickname()).setAvatar(user.getAvatar())));
return helpVOs;
}
List<AppBargainHelpRespVO> convertList02(List<BargainHelpDO> helps);
}
package org.dromara.mall.convert.promotion.bargain;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mall.util.collection.MapUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.api.dto.product.ProductSpuRespDTO;
import org.dromara.mall.api.dto.trade.TradeOrderRespDTO;
import org.dromara.mall.controller.promotion.admin.bargain.vo.recrod.BargainRecordPageItemRespVO;
import org.dromara.mall.controller.promotion.app.bargain.vo.record.AppBargainRecordDetailRespVO;
import org.dromara.mall.controller.promotion.app.bargain.vo.record.AppBargainRecordRespVO;
import org.dromara.mall.controller.promotion.app.bargain.vo.record.AppBargainRecordSummaryRespVO;
import org.dromara.mall.domain.promotion.BargainActivityDO;
import org.dromara.mall.domain.promotion.BargainRecordDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
/**
* 砍价记录 Convert
*
* @author 芋道源码
*/
@Mapper
public interface BargainRecordConvert {
BargainRecordConvert INSTANCE = Mappers.getMapper(BargainRecordConvert.class);
default PageResult<BargainRecordPageItemRespVO> convertPage(PageResult<BargainRecordDO> page,
Map<Long, Integer> helpCountMap,
List<BargainActivityDO> activityList,
Map<Long, MemberUserRespDTO> userMap) {
PageResult<BargainRecordPageItemRespVO> pageResult = convertPage(page);
// 拼接数据
Map<Long, BargainActivityDO> activityMap = convertMap(activityList, BargainActivityDO::getId);
pageResult.getList().forEach(record -> {
MapUtils.findAndThen(userMap, record.getUserId(),
user -> record.setNickname(user.getNickname()).setAvatar(user.getAvatar()));
record.setActivity(BargainActivityConvert.INSTANCE.convert(activityMap.get(record.getActivityId())))
.setHelpCount(helpCountMap.getOrDefault(record.getId(), 0));
});
return pageResult;
}
PageResult<BargainRecordPageItemRespVO> convertPage(PageResult<BargainRecordDO> page);
default PageResult<AppBargainRecordRespVO> convertPage02(PageResult<BargainRecordDO> page,
List<BargainActivityDO> activityList,
List<ProductSpuRespDTO> spuList,
List<TradeOrderRespDTO> orderList) {
PageResult<AppBargainRecordRespVO> pageResult = convertPage02(page);
// 拼接数据
Map<Long, BargainActivityDO> activityMap = convertMap(activityList, BargainActivityDO::getId);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, TradeOrderRespDTO> orderMap = convertMap(orderList, TradeOrderRespDTO::getId);
pageResult.getList().forEach(record -> {
MapUtils.findAndThen(activityMap, record.getActivityId(),
activity -> record.setActivityName(activity.getName()).setEndTime(activity.getEndTime()));
MapUtils.findAndThen(spuMap, record.getSpuId(),
spu -> record.setPicUrl(record.getPicUrl()));
MapUtils.findAndThen(orderMap, record.getOrderId(),
order -> record.setPayStatus(order.getPayStatus()).setPayOrderId(order.getPayOrderId()));
});
return pageResult;
}
PageResult<AppBargainRecordRespVO> convertPage02(PageResult<BargainRecordDO> page);
default AppBargainRecordSummaryRespVO convert(Integer successUserCount, List<BargainRecordDO> successList,
List<BargainActivityDO> activityList, Map<Long, MemberUserRespDTO> userMap) {
AppBargainRecordSummaryRespVO summary = new AppBargainRecordSummaryRespVO().setSuccessUserCount(successUserCount);
Map<Long, BargainActivityDO> activityMap = convertMap(activityList, BargainActivityDO::getId);
summary.setSuccessList(CollectionUtils.convertList(successList, record -> {
AppBargainRecordSummaryRespVO.Record recordVO = new AppBargainRecordSummaryRespVO.Record();
MapUtils.findAndThen(userMap, record.getUserId(),
user -> recordVO.setNickname(user.getNickname()).setAvatar(user.getAvatar()));
MapUtils.findAndThen(activityMap, record.getActivityId(),
activity -> recordVO.setActivityName(activity.getName()));
return recordVO;
}));
return summary;
}
@Mapping(source = "record.id", target = "id")
@Mapping(source = "record.userId", target = "userId")
@Mapping(source = "record.status", target = "status")
AppBargainRecordDetailRespVO convert02(BargainRecordDO record, Integer helpAction, TradeOrderRespDTO order);
}
package org.dromara.mall.convert.promotion.combination;
import cn.hutool.core.util.ObjectUtil;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.api.dto.product.ProductSkuRespDTO;
import org.dromara.mall.api.dto.product.ProductSpuRespDTO;
import org.dromara.mall.api.dto.promotion.CombinationRecordCreateReqDTO;
import org.dromara.mall.api.dto.promotion.CombinationRecordCreateRespDTO;
import org.dromara.mall.controller.promotion.admin.combination.vo.activity.CombinationActivityCreateReqVO;
import org.dromara.mall.controller.promotion.admin.combination.vo.activity.CombinationActivityPageItemRespVO;
import org.dromara.mall.controller.promotion.admin.combination.vo.activity.CombinationActivityRespVO;
import org.dromara.mall.controller.promotion.admin.combination.vo.activity.CombinationActivityUpdateReqVO;
import org.dromara.mall.controller.promotion.admin.combination.vo.product.CombinationProductBaseVO;
import org.dromara.mall.controller.promotion.admin.combination.vo.product.CombinationProductRespVO;
import org.dromara.mall.controller.promotion.admin.combination.vo.recrod.CombinationRecordPageItemRespVO;
import org.dromara.mall.controller.promotion.app.combination.vo.activity.AppCombinationActivityDetailRespVO;
import org.dromara.mall.controller.promotion.app.combination.vo.activity.AppCombinationActivityRespVO;
import org.dromara.mall.controller.promotion.app.combination.vo.record.AppCombinationRecordDetailRespVO;
import org.dromara.mall.controller.promotion.app.combination.vo.record.AppCombinationRecordRespVO;
import org.dromara.mall.domain.promotion.CombinationActivityDO;
import org.dromara.mall.domain.promotion.CombinationProductDO;
import org.dromara.mall.domain.promotion.CombinationRecordDO;
import org.dromara.mall.enums.promotion.combination.CombinationRecordStatusEnum;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.*;
import static org.dromara.common.mall.util.collection.MapUtils.findAndThen;
/**
* 拼团活动 Convert
*
* @author HUIHUI
*/
@Mapper
public interface CombinationActivityConvert {
CombinationActivityConvert INSTANCE = Mappers.getMapper(CombinationActivityConvert.class);
CombinationActivityDO convert(CombinationActivityCreateReqVO bean);
CombinationActivityDO convert(CombinationActivityUpdateReqVO bean);
CombinationActivityRespVO convert(CombinationActivityDO bean);
CombinationProductRespVO convert(CombinationProductDO bean);
default CombinationActivityRespVO convert(CombinationActivityDO activity, List<CombinationProductDO> products) {
return convert(activity).setProducts(convertList2(products));
}
List<CombinationActivityRespVO> convertList(List<CombinationActivityDO> list);
default PageResult<CombinationActivityPageItemRespVO> convertPage(PageResult<CombinationActivityDO> page,
List<CombinationProductDO> productList,
Map<Long, Integer> groupCountMap,
Map<Long, Integer> groupSuccessCountMap,
Map<Long, Integer> recordCountMap,
List<ProductSpuRespDTO> spuList) {
PageResult<CombinationActivityPageItemRespVO> pageResult = convertPage(page);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<CombinationProductDO>> productMap = convertMultiMap(productList, CombinationProductDO::getActivityId);
pageResult.getList().forEach(item -> {
findAndThen(spuMap, item.getSpuId(), spu -> item.setSpuName(spu.getName()).setPicUrl(spu.getPicUrl())
.setMarketPrice(spu.getMarketPrice()));
item.setProducts(convertList2(productMap.get(item.getId())));
// 设置统计字段
item.setGroupCount(groupCountMap.getOrDefault(item.getId(), 0))
.setGroupSuccessCount(groupSuccessCountMap.getOrDefault(item.getId(), 0))
.setRecordCount(recordCountMap.getOrDefault(item.getId(), 0));
});
return pageResult;
}
PageResult<CombinationActivityPageItemRespVO> convertPage(PageResult<CombinationActivityDO> page);
List<CombinationProductRespVO> convertList2(List<CombinationProductDO> productDOs);
@Mappings({
@Mapping(target = "id", ignore = true),
@Mapping(target = "activityId", source = "activity.id"),
@Mapping(target = "spuId", source = "activity.spuId"),
@Mapping(target = "skuId", source = "product.skuId"),
@Mapping(target = "combinationPrice", source = "product.combinationPrice"),
@Mapping(target = "activityStartTime", source = "activity.startTime"),
@Mapping(target = "activityEndTime", source = "activity.endTime")
})
CombinationProductDO convert(CombinationActivityDO activity, CombinationProductBaseVO product);
default List<CombinationProductDO> convertList(List<? extends CombinationProductBaseVO> products, CombinationActivityDO activity) {
return CollectionUtils.convertList(products, item -> convert(activity, item).setActivityStatus(activity.getStatus()));
}
default List<CombinationProductDO> convertList(List<CombinationProductBaseVO> updateProductVOs,
List<CombinationProductDO> products, CombinationActivityDO activity) {
Map<Long, Long> productMap = convertMap(products, CombinationProductDO::getSkuId, CombinationProductDO::getId);
return CollectionUtils.convertList(updateProductVOs, updateProductVO -> convert(activity, updateProductVO)
.setId(productMap.get(updateProductVO.getSkuId()))
.setActivityStatus(activity.getStatus()));
}
CombinationRecordDO convert(CombinationRecordCreateReqDTO reqDTO);
default CombinationRecordCreateRespDTO convert4(CombinationRecordDO combinationRecord) {
return new CombinationRecordCreateRespDTO().setCombinationActivityId(combinationRecord.getActivityId())
.setCombinationRecordId(combinationRecord.getId()).setCombinationHeadId(combinationRecord.getHeadId());
}
default CombinationRecordDO convert(CombinationRecordCreateReqDTO reqDTO,
CombinationActivityDO activity, MemberUserRespDTO user,
ProductSpuRespDTO spu, ProductSkuRespDTO sku) {
return convert(reqDTO).setVirtualGroup(false)
.setStatus(CombinationRecordStatusEnum.IN_PROGRESS.getStatus()) // 创建后默认状态为进行中
.setUserSize(activity.getUserSize()).setUserCount(1) // 默认就是 1 插入后会接着更新一次所有的拼团记录
// 用户信息
.setNickname(user.getNickname()).setAvatar(user.getAvatar())
// 商品信息
.setSpuName(spu.getName()).setPicUrl(sku.getPicUrl());
}
default List<CombinationActivityRespVO> convertList(List<CombinationActivityDO> list,
List<CombinationProductDO> productList,
List<ProductSpuRespDTO> spuList) {
List<CombinationActivityRespVO> activityList = BeanUtils.toBean(list, CombinationActivityRespVO.class);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<CombinationProductDO>> productMap = convertMultiMap(productList, CombinationProductDO::getActivityId);
return CollectionUtils.convertList(activityList, item -> {
// 设置 product 信息
item.setCombinationPrice(getMinValue(productMap.get(item.getId()), CombinationProductDO::getCombinationPrice));
// 设置 SPU 信息
findAndThen(spuMap, item.getSpuId(), spu -> item.setSpuName(spu.getName())
.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
});
}
default List<AppCombinationActivityRespVO> convertAppList(List<CombinationActivityDO> list,
List<CombinationProductDO> productList,
List<ProductSpuRespDTO> spuList) {
List<AppCombinationActivityRespVO> activityList = BeanUtils.toBean(list, AppCombinationActivityRespVO.class);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<CombinationProductDO>> productMap = convertMultiMap(productList, CombinationProductDO::getActivityId);
return CollectionUtils.convertList(activityList, item -> {
// 设置 product 信息
item.setCombinationPrice(getMinValue(productMap.get(item.getId()), CombinationProductDO::getCombinationPrice));
// 设置 SPU 信息
findAndThen(spuMap, item.getSpuId(), spu -> item.setSpuName(spu.getName())
.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
});
}
default PageResult<AppCombinationActivityRespVO> convertAppPage(PageResult<CombinationActivityDO> result,
List<CombinationProductDO> productList,
List<ProductSpuRespDTO> spuList) {
return new PageResult<>(convertAppList(result.getList(), productList, spuList), result.getTotal());
}
AppCombinationActivityDetailRespVO convert2(CombinationActivityDO combinationActivity);
List<AppCombinationActivityDetailRespVO.Product> convertList1(List<CombinationProductDO> products);
default AppCombinationActivityDetailRespVO convert3(CombinationActivityDO combinationActivity, List<CombinationProductDO> products) {
return convert2(combinationActivity).setProducts(convertList1(products));
}
List<AppCombinationRecordRespVO> convertList3(List<CombinationRecordDO> records);
AppCombinationRecordRespVO convert(CombinationRecordDO record);
PageResult<CombinationRecordPageItemRespVO> convert(PageResult<CombinationRecordDO> result);
default PageResult<CombinationRecordPageItemRespVO> convert(PageResult<CombinationRecordDO> recordPage, List<CombinationActivityDO> activities, List<CombinationProductDO> products) {
PageResult<CombinationRecordPageItemRespVO> result = convert(recordPage);
// 拼接关联属性
Map<Long, CombinationActivityDO> activityMap = convertMap(activities, CombinationActivityDO::getId);
Map<Long, List<CombinationProductDO>> productsMap = convertMultiMap(products, CombinationProductDO::getActivityId);
result.setList(CollectionUtils.convertList(result.getList(), item -> {
findAndThen(activityMap, item.getActivityId(), activity -> {
item.setActivity(convert(activity).setProducts(convertList2(productsMap.get(item.getActivityId()))));
});
return item;
}));
return result;
}
default AppCombinationRecordDetailRespVO convert(Long userId, CombinationRecordDO headRecord, List<CombinationRecordDO> memberRecords) {
AppCombinationRecordDetailRespVO respVO = new AppCombinationRecordDetailRespVO()
.setHeadRecord(convert(headRecord)).setMemberRecords(convertList3(memberRecords));
// 处理自己参与拼团的 orderId
CombinationRecordDO userRecord = CollectionUtils.findFirst(memberRecords, r -> ObjectUtil.equal(r.getUserId(), userId));
if (userRecord == null && ObjectUtil.equal(headRecord.getUserId(), userId)) {
userRecord = headRecord;
}
respVO.setOrderId(userRecord == null ? null : userRecord.getOrderId());
return respVO;
}
/**
* 转换生成虚拟成团虚拟记录
*
* @param headRecord 虚拟成团团长记录
* @return 虚拟记录列表
*/
default List<CombinationRecordDO> convertVirtualRecordList(CombinationRecordDO headRecord) {
int count = headRecord.getUserSize() - headRecord.getUserCount();
List<CombinationRecordDO> createRecords = new ArrayList<>(count);
for (int i = 0; i < count; i++) {
// 基础信息和团长保持一致
CombinationRecordDO newRecord = convert5(headRecord).setHeadId(headRecord.getId());
// 虚拟信息
newRecord.setCount(0) // 会单独更新下,在后续的 Service 逻辑里
.setUserId(0L).setNickname("").setAvatar("").setOrderId(0L);
createRecords.add(newRecord);
}
return createRecords;
}
@Mapping(target = "id", ignore = true)
CombinationRecordDO convert5(CombinationRecordDO headRecord);
}
package org.dromara.mall.convert.promotion.coupon;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.promotion.CouponRespDTO;
import org.dromara.mall.controller.promotion.admin.coupon.vo.coupon.CouponPageItemRespVO;
import org.dromara.mall.controller.promotion.admin.coupon.vo.coupon.CouponPageReqVO;
import org.dromara.mall.controller.promotion.app.coupon.vo.coupon.AppCouponPageReqVO;
import org.dromara.mall.domain.promotion.CouponDO;
import org.dromara.mall.domain.promotion.CouponTemplateDO;
import org.dromara.mall.enums.promotion.coupon.CouponStatusEnum;
import org.dromara.mall.enums.promotion.coupon.CouponTemplateValidityTypeEnum;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.time.LocalDateTime;
import java.util.Collection;
/**
* 优惠劵 Convert
*
* @author 芋道源码
*/
@Mapper
public interface CouponConvert {
CouponConvert INSTANCE = Mappers.getMapper(CouponConvert.class);
PageResult<CouponPageItemRespVO> convertPage(PageResult<CouponDO> page);
CouponRespDTO convert(CouponDO bean);
default CouponDO convert(CouponTemplateDO template, Long userId) {
CouponDO couponDO = new CouponDO()
.setTemplateId(template.getId())
.setName(template.getName())
.setTakeType(template.getTakeType())
.setUsePrice(template.getUsePrice())
.setProductScope(template.getProductScope())
.setProductScopeValues(template.getProductScopeValues())
.setDiscountType(template.getDiscountType())
.setDiscountPercent(template.getDiscountPercent())
.setDiscountPrice(template.getDiscountPrice())
.setDiscountLimitPrice(template.getDiscountLimitPrice())
.setStatus(CouponStatusEnum.UNUSED.getStatus())
.setUserId(userId);
if (CouponTemplateValidityTypeEnum.DATE.getType().equals(template.getValidityType())) {
couponDO.setValidStartTime(template.getValidStartTime());
couponDO.setValidEndTime(template.getValidEndTime());
} else if (CouponTemplateValidityTypeEnum.TERM.getType().equals(template.getValidityType())) {
couponDO.setValidStartTime(LocalDateTime.now().plusDays(template.getFixedStartTerm()));
couponDO.setValidEndTime(LocalDateTime.now().plusDays(template.getFixedEndTerm()));
}
return couponDO;
}
CouponPageReqVO convert(AppCouponPageReqVO pageReqVO, Collection<Long> userIds);
}
package org.dromara.mall.convert.promotion.coupon;
import cn.hutool.core.map.MapUtil;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.promotion.admin.coupon.vo.template.CouponTemplateCreateReqVO;
import org.dromara.mall.controller.promotion.admin.coupon.vo.template.CouponTemplatePageReqVO;
import org.dromara.mall.controller.promotion.admin.coupon.vo.template.CouponTemplateRespVO;
import org.dromara.mall.controller.promotion.admin.coupon.vo.template.CouponTemplateUpdateReqVO;
import org.dromara.mall.controller.promotion.app.coupon.vo.template.AppCouponTemplatePageReqVO;
import org.dromara.mall.controller.promotion.app.coupon.vo.template.AppCouponTemplateRespVO;
import org.dromara.mall.domain.promotion.CouponTemplateDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
/**
* 优惠劵模板 Convert
*
* @author 芋道源码
*/
@Mapper
public interface CouponTemplateConvert {
CouponTemplateConvert INSTANCE = Mappers.getMapper(CouponTemplateConvert.class);
CouponTemplateDO convert(CouponTemplateCreateReqVO bean);
CouponTemplateDO convert(CouponTemplateUpdateReqVO bean);
CouponTemplateRespVO convert(CouponTemplateDO bean);
PageResult<CouponTemplateRespVO> convertPage(PageResult<CouponTemplateDO> page);
CouponTemplatePageReqVO convert(AppCouponTemplatePageReqVO pageReqVO, List<Integer> canTakeTypes, Integer productScope, Long productScopeValue);
PageResult<AppCouponTemplateRespVO> convertAppPage(PageResult<CouponTemplateDO> pageResult);
List<AppCouponTemplateRespVO> convertAppList(List<CouponTemplateDO> list);
default PageResult<AppCouponTemplateRespVO> convertAppPage(PageResult<CouponTemplateDO> pageResult, Map<Long, Boolean> userCanTakeMap) {
PageResult<AppCouponTemplateRespVO> result = convertAppPage(pageResult);
copyTo(result.getList(), userCanTakeMap);
return result;
}
default List<AppCouponTemplateRespVO> convertAppList(List<CouponTemplateDO> list, Map<Long, Boolean> userCanTakeMap) {
List<AppCouponTemplateRespVO> result = convertAppList(list);
copyTo(result, userCanTakeMap);
return result;
}
default void copyTo(List<AppCouponTemplateRespVO> list, Map<Long, Boolean> userCanTakeMap) {
for (AppCouponTemplateRespVO template : list) {
// 检查已领取数量是否超过限领数量
template.setCanTake(MapUtil.getBool(userCanTakeMap, template.getId(), false));
}
}
List<CouponTemplateRespVO> convertList(List<CouponTemplateDO> list);
}
package org.dromara.mall.convert.promotion.discount;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.controller.promotion.admin.discount.vo.DiscountActivityBaseVO;
import org.dromara.mall.controller.promotion.admin.discount.vo.DiscountActivityCreateReqVO;
import org.dromara.mall.controller.promotion.admin.discount.vo.DiscountActivityRespVO;
import org.dromara.mall.controller.promotion.admin.discount.vo.DiscountActivityUpdateReqVO;
import org.dromara.mall.domain.promotion.DiscountActivityDO;
import org.dromara.mall.domain.promotion.DiscountProductDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 限时折扣活动 Convert
*
* @author 芋道源码
*/
@Mapper
public interface DiscountActivityConvert {
DiscountActivityConvert INSTANCE = Mappers.getMapper(DiscountActivityConvert.class);
DiscountActivityDO convert(DiscountActivityCreateReqVO bean);
DiscountActivityDO convert(DiscountActivityUpdateReqVO bean);
DiscountActivityRespVO convert(DiscountActivityDO bean);
List<DiscountActivityRespVO> convertList(List<DiscountActivityDO> list);
List<DiscountActivityBaseVO.Product> convertList2(List<DiscountProductDO> list);
PageResult<DiscountActivityRespVO> convertPage(PageResult<DiscountActivityDO> page);
default PageResult<DiscountActivityRespVO> convertPage(PageResult<DiscountActivityDO> page,
List<DiscountProductDO> discountProductDOList) {
PageResult<DiscountActivityRespVO> pageResult = convertPage(page);
pageResult.getList().forEach(item -> item.setProducts(convertList2(discountProductDOList)));
return pageResult;
}
DiscountProductDO convert(DiscountActivityBaseVO.Product bean);
default DiscountActivityRespVO convert(DiscountActivityDO activity, List<DiscountProductDO> products) {
return BeanUtils.toBean(activity, DiscountActivityRespVO.class).setProducts(convertList2(products));
}
}
package org.dromara.mall.convert.promotion.diy;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.promotion.admin.diy.vo.page.*;
import org.dromara.mall.domain.promotion.DiyPageDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 装修页面 Convert
*
* @author owen
*/
@Mapper
public interface DiyPageConvert {
DiyPageConvert INSTANCE = Mappers.getMapper(DiyPageConvert.class);
DiyPageDO convert(DiyPageCreateReqVO bean);
DiyPageDO convert(DiyPageUpdateReqVO bean);
DiyPageRespVO convert(DiyPageDO bean);
List<DiyPageRespVO> convertList(List<DiyPageDO> list);
PageResult<DiyPageRespVO> convertPage(PageResult<DiyPageDO> page);
DiyPageCreateReqVO convertCreateVo(Long templateId, String name, String remark);
DiyPagePropertyRespVO convertPropertyVo(DiyPageDO diyPage);
DiyPageDO convert(DiyPagePropertyUpdateRequestVO updateReqVO);
}
package org.dromara.mall.convert.promotion.diy;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.promotion.admin.diy.vo.template.*;
import org.dromara.mall.controller.promotion.app.diy.vo.AppDiyTemplatePropertyRespVO;
import org.dromara.mall.domain.promotion.DiyPageDO;
import org.dromara.mall.domain.promotion.DiyTemplateDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 装修模板 Convert
*
* @author owen
*/
@Mapper
public interface DiyTemplateConvert {
DiyTemplateConvert INSTANCE = Mappers.getMapper(DiyTemplateConvert.class);
DiyTemplateDO convert(DiyTemplateCreateReqVO bean);
DiyTemplateDO convert(DiyTemplateUpdateReqVO bean);
DiyTemplateRespVO convert(DiyTemplateDO bean);
List<DiyTemplateRespVO> convertList(List<DiyTemplateDO> list);
PageResult<DiyTemplateRespVO> convertPage(PageResult<DiyTemplateDO> page);
DiyTemplatePropertyRespVO convertPropertyVo(DiyTemplateDO diyTemplate, List<DiyPageDO> pages);
AppDiyTemplatePropertyRespVO convertPropertyVo2(DiyTemplateDO diyTemplate, String home, String user);
DiyTemplateDO convert(DiyTemplatePropertyUpdateRequestVO updateReqVO);
}
package org.dromara.mall.convert.promotion.seckill;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.common.mybatis.util.BeanUtils;
import org.dromara.mall.api.dto.product.ProductSpuRespDTO;
import org.dromara.mall.api.dto.promotion.SeckillValidateJoinRespDTO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.activity.SeckillActivityCreateReqVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.activity.SeckillActivityDetailRespVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.activity.SeckillActivityRespVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.activity.SeckillActivityUpdateReqVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.product.SeckillProductBaseVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.product.SeckillProductRespVO;
import org.dromara.mall.controller.promotion.app.seckill.vo.activity.AppSeckillActivityDetailRespVO;
import org.dromara.mall.controller.promotion.app.seckill.vo.activity.AppSeckillActivityNowRespVO;
import org.dromara.mall.controller.promotion.app.seckill.vo.activity.AppSeckillActivityRespVO;
import org.dromara.mall.domain.promotion.SeckillActivityDO;
import org.dromara.mall.domain.promotion.SeckillConfigDO;
import org.dromara.mall.domain.promotion.SeckillProductDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.*;
import static org.dromara.common.mall.util.collection.MapUtils.findAndThen;
/**
* 秒杀活动 Convert
*
* @author 芋道源码
*/
@Mapper
public interface SeckillActivityConvert {
SeckillActivityConvert INSTANCE = Mappers.getMapper(SeckillActivityConvert.class);
SeckillActivityDO convert(SeckillActivityCreateReqVO bean);
SeckillActivityDO convert(SeckillActivityUpdateReqVO bean);
SeckillActivityRespVO convert(SeckillActivityDO bean);
List<SeckillActivityRespVO> convertList(List<SeckillActivityDO> list);
PageResult<SeckillActivityRespVO> convertPage(PageResult<SeckillActivityDO> page);
default PageResult<SeckillActivityRespVO> convertPage(PageResult<SeckillActivityDO> page,
List<SeckillProductDO> seckillProducts,
List<ProductSpuRespDTO> spuList) {
PageResult<SeckillActivityRespVO> pageResult = convertPage(page);
// 拼接商品
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<SeckillProductDO>> productMap = convertMultiMap(seckillProducts, SeckillProductDO::getActivityId);
pageResult.getList().forEach(activity -> {
activity.setProducts(convertList2(productMap.get(activity.getId())));
findAndThen(spuMap, activity.getSpuId(),
spu -> activity.setSpuName(spu.getName()).setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
});
return pageResult;
}
SeckillActivityDetailRespVO convert1(SeckillActivityDO activity);
default SeckillActivityDetailRespVO convert(SeckillActivityDO activity, List<SeckillProductDO> products) {
return convert1(activity).setProducts(convertList2(products));
}
@Mappings({
@Mapping(target = "id", ignore = true),
@Mapping(target = "activityId", source = "activity.id"),
@Mapping(target = "configIds", source = "activity.configIds"),
@Mapping(target = "spuId", source = "activity.spuId"),
@Mapping(target = "skuId", source = "product.skuId"),
@Mapping(target = "seckillPrice", source = "product.seckillPrice"),
@Mapping(target = "stock", source = "product.stock"),
@Mapping(target = "activityStartTime", source = "activity.startTime"),
@Mapping(target = "activityEndTime", source = "activity.endTime")
})
SeckillProductDO convert(SeckillActivityDO activity, SeckillProductBaseVO product);
default List<SeckillProductDO> convertList(List<? extends SeckillProductBaseVO> products, SeckillActivityDO activity) {
return CollectionUtils.convertList(products, item -> convert(activity, item).setActivityStatus(activity.getStatus()));
}
default List<SeckillActivityRespVO> convertList(List<SeckillActivityDO> list,
List<SeckillProductDO> productList,
List<ProductSpuRespDTO> spuList) {
List<SeckillActivityRespVO> activityList = BeanUtils.toBean(list, SeckillActivityRespVO.class);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<SeckillProductDO>> productMap = convertMultiMap(productList, SeckillProductDO::getActivityId);
return CollectionUtils.convertList(activityList, item -> {
// 设置 product 信息
item.setSeckillPrice(getMinValue(productMap.get(item.getId()), SeckillProductDO::getSeckillPrice));
// 设置 SPU 信息
findAndThen(spuMap, item.getSpuId(), spu -> item.setSpuName(spu.getName())
.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
});
}
default List<AppSeckillActivityRespVO> convertAppList(List<SeckillActivityDO> list,
List<SeckillProductDO> productList,
List<ProductSpuRespDTO> spuList) {
List<AppSeckillActivityRespVO> activityList = BeanUtils.toBean(list, AppSeckillActivityRespVO.class);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<SeckillProductDO>> productMap = convertMultiMap(productList, SeckillProductDO::getActivityId);
return CollectionUtils.convertList(activityList, item -> {
// 设置 product 信息
item.setSeckillPrice(getMinValue(productMap.get(item.getId()), SeckillProductDO::getSeckillPrice));
// 设置 SPU 信息
findAndThen(spuMap, item.getSpuId(), spu -> item.setSpuName(spu.getName())
.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
});
}
List<SeckillProductRespVO> convertList2(List<SeckillProductDO> list);
List<AppSeckillActivityRespVO> convertList3(List<SeckillActivityDO> activityList);
default AppSeckillActivityNowRespVO convert(SeckillConfigDO filteredConfig, List<SeckillActivityDO> activityList,
List<SeckillProductDO> productList, List<ProductSpuRespDTO> spuList) {
AppSeckillActivityNowRespVO respVO = new AppSeckillActivityNowRespVO();
respVO.setConfig(SeckillConfigConvert.INSTANCE.convert1(filteredConfig));
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<SeckillProductDO>> productMap = convertMultiMap(productList, SeckillProductDO::getActivityId);
respVO.setActivities(CollectionUtils.convertList(convertList3(activityList), item -> {
// product 信息
item.setSeckillPrice(getMinValue(productMap.get(item.getId()), SeckillProductDO::getSeckillPrice));
// spu 信息
findAndThen(spuMap, item.getSpuId(), spu ->
item.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
}));
return respVO;
}
PageResult<AppSeckillActivityRespVO> convertPage1(PageResult<SeckillActivityDO> pageResult);
default PageResult<AppSeckillActivityRespVO> convertPage02(PageResult<SeckillActivityDO> pageResult, List<SeckillProductDO> productList, List<ProductSpuRespDTO> spuList) {
PageResult<AppSeckillActivityRespVO> result = convertPage1(pageResult);
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spuList, ProductSpuRespDTO::getId);
Map<Long, List<SeckillProductDO>> productMap = convertMultiMap(productList, SeckillProductDO::getActivityId);
List<AppSeckillActivityRespVO> list = CollectionUtils.convertList(result.getList(), item -> {
// product 信息
item.setSeckillPrice(getMinValue(productMap.get(item.getId()), SeckillProductDO::getSeckillPrice));
// spu 信息
findAndThen(spuMap, item.getSpuId(), spu -> item.setPicUrl(spu.getPicUrl()).setMarketPrice(spu.getMarketPrice()));
return item;
});
result.setList(list);
return result;
}
AppSeckillActivityDetailRespVO convert2(SeckillActivityDO seckillActivity);
List<AppSeckillActivityDetailRespVO.Product> convertList1(List<SeckillProductDO> products);
default AppSeckillActivityDetailRespVO convert3(SeckillActivityDO activity, List<SeckillProductDO> products,
LocalDateTime startTime, LocalDateTime endTime) {
return convert2(activity)
.setProducts(convertList1(products))
.setStartTime(startTime).setEndTime(endTime);
}
SeckillValidateJoinRespDTO convert02(SeckillActivityDO activity, SeckillProductDO product);
}
package org.dromara.mall.convert.promotion.seckill;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.promotion.admin.seckill.vo.config.SeckillConfigCreateReqVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.config.SeckillConfigRespVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.config.SeckillConfigSimpleRespVO;
import org.dromara.mall.controller.promotion.admin.seckill.vo.config.SeckillConfigUpdateReqVO;
import org.dromara.mall.controller.promotion.app.seckill.vo.config.AppSeckillConfigRespVO;
import org.dromara.mall.domain.promotion.SeckillConfigDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
/**
* 秒杀时段 Convert
*
* @author 芋道源码
*/
@Mapper
public interface SeckillConfigConvert {
SeckillConfigConvert INSTANCE = Mappers.getMapper(SeckillConfigConvert.class);
SeckillConfigDO convert(SeckillConfigCreateReqVO bean);
SeckillConfigDO convert(SeckillConfigUpdateReqVO bean);
SeckillConfigRespVO convert(SeckillConfigDO bean);
List<SeckillConfigRespVO> convertList(List<SeckillConfigDO> list);
List<SeckillConfigSimpleRespVO> convertList1(List<SeckillConfigDO> list);
PageResult<SeckillConfigRespVO> convertPage(PageResult<SeckillConfigDO> page);
List<AppSeckillConfigRespVO> convertList2(List<SeckillConfigDO> list);
AppSeckillConfigRespVO convert1(SeckillConfigDO filteredConfig);
}
package org.dromara.mall.convert.statistics.member;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjUtil;
import org.dromara.common.mall.domain.Area;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.mall.controller.statistics.admin.common.vo.DataComparisonRespVO;
import org.dromara.mall.controller.statistics.admin.member.vo.MemberAnalyseDataRespVO;
import org.dromara.mall.controller.statistics.admin.member.vo.MemberAnalyseRespVO;
import org.dromara.mall.controller.statistics.admin.member.vo.MemberAreaStatisticsRespVO;
import org.dromara.mall.controller.statistics.admin.member.vo.MemberSummaryRespVO;
import org.dromara.mall.service.statistics.member.bo.MemberAreaStatisticsRespBO;
import org.dromara.mall.service.statistics.pay.bo.RechargeSummaryRespBO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import java.util.Optional;
/**
* 会员统计 Convert
*
* @author owen
*/
@Mapper
public interface MemberStatisticsConvert {
MemberStatisticsConvert INSTANCE = Mappers.getMapper(MemberStatisticsConvert.class);
default List<MemberAreaStatisticsRespVO> convertList(List<Area> areaList,
Map<Integer, Integer> userCountMap,
Map<Integer, MemberAreaStatisticsRespBO> orderMap) {
return CollectionUtils.convertList(areaList, area -> {
MemberAreaStatisticsRespBO orderVo = Optional.ofNullable(orderMap.get(area.getId()))
.orElseGet(MemberAreaStatisticsRespBO::new);
return new MemberAreaStatisticsRespVO()
.setAreaId(area.getId()).setAreaName(area.getName())
.setUserCount(MapUtil.getInt(userCountMap, area.getId(), 0))
.setOrderCreateUserCount(ObjUtil.defaultIfNull(orderVo.getOrderCreateUserCount(), 0))
.setOrderPayUserCount(ObjUtil.defaultIfNull(orderVo.getOrderPayUserCount(), 0))
.setOrderPayPrice(ObjUtil.defaultIfNull(orderVo.getOrderPayPrice(), 0));
});
}
MemberSummaryRespVO convert(RechargeSummaryRespBO rechargeSummary, Integer expensePrice, Integer userCount);
MemberAnalyseRespVO convert(Integer visitUserCount, Integer orderUserCount, Integer payUserCount, int atv,
DataComparisonRespVO<MemberAnalyseDataRespVO> comparison);
}
package org.dromara.mall.convert.statistics.pay;
import org.dromara.mall.controller.statistics.admin.pay.vo.PaySummaryRespVO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* 支付统计 Convert
*
* @author owen
*/
@Mapper
public interface PayStatisticsConvert {
PayStatisticsConvert INSTANCE = Mappers.getMapper(PayStatisticsConvert.class);
PaySummaryRespVO convert(Integer rechargePrice);
}
package org.dromara.mall.convert.statistics.trade;
import org.dromara.mall.controller.statistics.admin.common.vo.DataComparisonRespVO;
import org.dromara.mall.controller.statistics.admin.trade.vo.TradeOrderCountRespVO;
import org.dromara.mall.controller.statistics.admin.trade.vo.TradeSummaryRespVO;
import org.dromara.mall.controller.statistics.admin.trade.vo.TradeTrendSummaryExcelVO;
import org.dromara.mall.controller.statistics.admin.trade.vo.TradeTrendSummaryRespVO;
import org.dromara.mall.domain.statistics.TradeStatisticsDO;
import org.dromara.mall.service.statistics.trade.bo.AfterSaleSummaryRespBO;
import org.dromara.mall.service.statistics.trade.bo.TradeOrderSummaryRespBO;
import org.dromara.mall.service.statistics.trade.bo.TradeSummaryRespBO;
import org.dromara.mall.service.statistics.trade.bo.WalletSummaryRespBO;
import org.mapstruct.IterableMapping;
import org.mapstruct.Mapper;
import org.mapstruct.Named;
import org.mapstruct.factory.Mappers;
import java.time.LocalDateTime;
import java.util.List;
/**
* 交易统计 Convert
*
* @author owen
*/
@Mapper
public interface TradeStatisticsConvert {
TradeStatisticsConvert INSTANCE = Mappers.getMapper(TradeStatisticsConvert.class);
default DataComparisonRespVO<TradeSummaryRespVO> convert(TradeSummaryRespBO yesterdayData,
TradeSummaryRespBO beforeYesterdayData,
TradeSummaryRespBO monthData,
TradeSummaryRespBO lastMonthData) {
return convert(convert(yesterdayData, monthData), convert(beforeYesterdayData, lastMonthData));
}
default TradeSummaryRespVO convert(TradeSummaryRespBO yesterdayData, TradeSummaryRespBO monthData) {
return new TradeSummaryRespVO()
.setYesterdayOrderCount(yesterdayData.getCount()).setYesterdayPayPrice(yesterdayData.getSummary())
.setMonthOrderCount(monthData.getCount()).setMonthPayPrice(monthData.getSummary());
}
DataComparisonRespVO<TradeSummaryRespVO> convert(TradeSummaryRespVO value, TradeSummaryRespVO reference);
DataComparisonRespVO<TradeTrendSummaryRespVO> convert(TradeTrendSummaryRespVO value,
TradeTrendSummaryRespVO reference);
List<TradeTrendSummaryExcelVO> convertList02(List<TradeTrendSummaryRespVO> list);
TradeStatisticsDO convert(LocalDateTime time, TradeOrderSummaryRespBO orderSummary,
AfterSaleSummaryRespBO afterSaleSummary, Integer brokerageSettlementPrice,
WalletSummaryRespBO walletSummary);
@IterableMapping(qualifiedByName = "convert")
List<TradeTrendSummaryRespVO> convertList(List<TradeStatisticsDO> list);
TradeTrendSummaryRespVO convertA(TradeStatisticsDO tradeStatistics);
@Named("convert")
default TradeTrendSummaryRespVO convert(TradeStatisticsDO tradeStatistics) {
TradeTrendSummaryRespVO vo = convertA(tradeStatistics);
return vo
.setDate(tradeStatistics.getTime().toLocalDate())
// 营业额 = 商品支付金额 + 充值金额
.setTurnoverPrice(tradeStatistics.getOrderPayPrice() + tradeStatistics.getRechargePayPrice())
// 支出金额 = 余额支付金额 + 支付佣金金额 + 商品退款金额
.setExpensePrice(tradeStatistics.getWalletPayPrice() + tradeStatistics.getBrokerageSettlementPrice() + tradeStatistics.getAfterSaleRefundPrice());
}
TradeOrderCountRespVO convert(Long undelivered, Long pickUp, Long afterSaleApply, Long auditingWithdraw);
}
package org.dromara.mall.convert.system;
import org.dromara.mall.api.dto.system.AdminUserRespDTO;
import org.dromara.system.api.domain.vo.RemoteUserVo;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public interface AdminUserConvert {
AdminUserConvert INSTANCE = Mappers.getMapper(AdminUserConvert.class);
@Mapping(target = "id", source = "userId")
@Mapping(target = "mobile", source = "phonenumber")
@Mapping(target = "status", expression = "java(java.lang.Integer.valueOf(user.getStatus()))")
AdminUserRespDTO convert(RemoteUserVo user);
List<AdminUserRespDTO> convertList(List<RemoteUserVo> list);
}
package org.dromara.mall.convert.trade.aftersale;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.api.dto.pay.PayRefundCreateReqDTO;
import org.dromara.mall.api.dto.product.ProductPropertyValueDetailRespDTO;
import org.dromara.mall.controller.trade.admin.aftersale.vo.AfterSaleDetailRespVO;
import org.dromara.mall.controller.trade.admin.aftersale.vo.AfterSaleRespPageItemVO;
import org.dromara.mall.controller.trade.admin.aftersale.vo.log.AfterSaleLogRespVO;
import org.dromara.mall.controller.trade.admin.base.member.user.MemberUserRespVO;
import org.dromara.mall.controller.trade.admin.base.product.property.ProductPropertyValueDetailRespVO;
import org.dromara.mall.controller.trade.admin.order.vo.TradeOrderBaseVO;
import org.dromara.mall.controller.trade.app.aftersale.vo.AppAfterSaleCreateReqVO;
import org.dromara.mall.controller.trade.app.aftersale.vo.AppAfterSaleRespVO;
import org.dromara.mall.domain.trade.AfterSaleDO;
import org.dromara.mall.domain.trade.AfterSaleLogDO;
import org.dromara.mall.domain.trade.TradeOrderDO;
import org.dromara.mall.domain.trade.TradeOrderItemDO;
import org.dromara.mall.framework.trade.order.config.TradeOrderProperties;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
@Mapper
public interface AfterSaleConvert {
AfterSaleConvert INSTANCE = Mappers.getMapper(AfterSaleConvert.class);
@Mappings({
@Mapping(target = "id", ignore = true),
@Mapping(target = "createTime", ignore = true),
@Mapping(target = "updateTime", ignore = true),
@Mapping(target = "createBy", ignore = true),
@Mapping(target = "updateBy", ignore = true),
})
AfterSaleDO convert(AppAfterSaleCreateReqVO createReqVO, TradeOrderItemDO tradeOrderItem);
@Mappings({
@Mapping(source = "afterSale.orderId", target = "merchantOrderId"),
@Mapping(source = "afterSale.id", target = "merchantRefundId"),
@Mapping(source = "afterSale.applyReason", target = "reason"),
@Mapping(source = "afterSale.refundPrice", target = "price"),
@Mapping(source = "orderProperties.payAppKey", target = "appKey")
})
PayRefundCreateReqDTO convert(String userIp, AfterSaleDO afterSale, TradeOrderProperties orderProperties);
MemberUserRespVO convert(MemberUserRespDTO bean);
PageResult<AfterSaleRespPageItemVO> convertPage(PageResult<AfterSaleDO> page);
default PageResult<AfterSaleRespPageItemVO> convertPage(PageResult<AfterSaleDO> pageResult,
Map<Long, MemberUserRespDTO> memberUsers) {
PageResult<AfterSaleRespPageItemVO> voPageResult = convertPage(pageResult);
// 处理会员
voPageResult.getList().forEach(afterSale -> afterSale.setUser(
convert(memberUsers.get(afterSale.getUserId()))));
return voPageResult;
}
ProductPropertyValueDetailRespVO convert(ProductPropertyValueDetailRespDTO bean);
AppAfterSaleRespVO convert(AfterSaleDO bean);
PageResult<AppAfterSaleRespVO> convertPage02(PageResult<AfterSaleDO> page);
default AfterSaleDetailRespVO convert(AfterSaleDO afterSale, TradeOrderDO order, TradeOrderItemDO orderItem,
MemberUserRespDTO user, List<AfterSaleLogDO> logs) {
AfterSaleDetailRespVO respVO = convert02(afterSale);
// 处理用户信息
respVO.setUser(convert(user));
// 处理订单信息
respVO.setOrder(convert(order));
respVO.setOrderItem(convert02(orderItem));
// 处理售后日志
respVO.setLogs(convertList1(logs));
return respVO;
}
List<AfterSaleLogRespVO> convertList1(List<AfterSaleLogDO> list);
AfterSaleDetailRespVO convert02(AfterSaleDO bean);
AfterSaleDetailRespVO.OrderItem convert02(TradeOrderItemDO bean);
TradeOrderBaseVO convert(TradeOrderDO bean);
}
package org.dromara.mall.convert.trade.aftersale;
import org.dromara.mall.domain.trade.AfterSaleLogDO;
import org.dromara.mall.service.trade.aftersale.bo.AfterSaleLogCreateReqBO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface AfterSaleLogConvert {
AfterSaleLogConvert INSTANCE = Mappers.getMapper(AfterSaleLogConvert.class);
AfterSaleLogDO convert(AfterSaleLogCreateReqBO bean);
}
package org.dromara.mall.convert.trade.brokerage;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import org.dromara.common.mall.util.number.MoneyUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.controller.trade.admin.brokerage.vo.record.BrokerageRecordPageReqVO;
import org.dromara.mall.controller.trade.admin.brokerage.vo.record.BrokerageRecordRespVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.record.AppBrokerageRecordPageReqVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.user.AppBrokerageUserRankByPriceRespVO;
import org.dromara.mall.domain.trade.BrokerageRecordDO;
import org.dromara.mall.domain.trade.BrokerageUserDO;
import org.dromara.mall.enums.trade.brokerage.BrokerageRecordBizTypeEnum;
import org.dromara.mall.enums.trade.brokerage.BrokerageRecordStatusEnum;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;
import org.mapstruct.factory.Mappers;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Optional;
/**
* 佣金记录 Convert
*
* @author owen
*/
@Mapper
public interface BrokerageRecordConvert {
BrokerageRecordConvert INSTANCE = Mappers.getMapper(BrokerageRecordConvert.class);
BrokerageRecordRespVO convert(BrokerageRecordDO bean);
List<BrokerageRecordRespVO> convertList(List<BrokerageRecordDO> list);
PageResult<BrokerageRecordRespVO> convertPage(PageResult<BrokerageRecordDO> page);
default BrokerageRecordDO convert(BrokerageUserDO user, BrokerageRecordBizTypeEnum bizType, String bizId,
Integer brokerageFrozenDays, int brokeragePrice, LocalDateTime unfreezeTime,
String title, Long sourceUserId, Integer sourceUserLevel) {
brokerageFrozenDays = ObjectUtil.defaultIfNull(brokerageFrozenDays, 0);
// 不冻结时,佣金直接就是结算状态
Integer status = brokerageFrozenDays > 0
? BrokerageRecordStatusEnum.WAIT_SETTLEMENT.getStatus()
: BrokerageRecordStatusEnum.SETTLEMENT.getStatus();
return new BrokerageRecordDO().setUserId(user.getId())
.setBizType(bizType.getType()).setBizId(bizId)
.setPrice(brokeragePrice).setTotalPrice(user.getBrokeragePrice())
.setTitle(title)
.setDescription(StrUtil.format(bizType.getDescription(), MoneyUtils.fenToYuanStr(Math.abs(brokeragePrice))))
.setStatus(status).setFrozenDays(brokerageFrozenDays).setUnfreezeTime(unfreezeTime)
.setSourceUserLevel(sourceUserLevel).setSourceUserId(sourceUserId);
}
default PageResult<BrokerageRecordRespVO> convertPage(PageResult<BrokerageRecordDO> pageResult, Map<Long, MemberUserRespDTO> userMap) {
PageResult<BrokerageRecordRespVO> result = convertPage(pageResult);
for (BrokerageRecordRespVO respVO : result.getList()) {
Optional.ofNullable(userMap.get(respVO.getUserId())).ifPresent(user ->
respVO.setUserNickname(user.getNickname()).setUserAvatar(user.getAvatar()));
Optional.ofNullable(userMap.get(respVO.getSourceUserId())).ifPresent(user ->
respVO.setSourceUserNickname(user.getNickname()).setSourceUserAvatar(user.getAvatar()));
}
return result;
}
BrokerageRecordPageReqVO convert(AppBrokerageRecordPageReqVO pageReqVO, Long userId);
default PageResult<AppBrokerageUserRankByPriceRespVO> convertPage03(PageResult<AppBrokerageUserRankByPriceRespVO> pageResult, Map<Long, MemberUserRespDTO> userMap) {
for (AppBrokerageUserRankByPriceRespVO vo : pageResult.getList()) {
copyTo(userMap.get(vo.getId()), vo);
}
return pageResult;
}
void copyTo(MemberUserRespDTO from, @MappingTarget AppBrokerageUserRankByPriceRespVO to);
}
package org.dromara.mall.convert.trade.brokerage;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjUtil;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.controller.trade.admin.brokerage.vo.user.BrokerageUserRespVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.user.AppBrokerageUserChildSummaryRespVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.user.AppBrokerageUserMySummaryRespVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.user.AppBrokerageUserRankByUserCountRespVO;
import org.dromara.mall.domain.trade.BrokerageUserDO;
import org.dromara.mall.service.trade.brokerage.bo.BrokerageWithdrawSummaryRespBO;
import org.dromara.mall.service.trade.brokerage.bo.UserBrokerageSummaryRespBO;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import java.util.Optional;
/**
* 分销用户 Convert
*
* @author owen
*/
@Mapper
public interface BrokerageUserConvert {
BrokerageUserConvert INSTANCE = Mappers.getMapper(BrokerageUserConvert.class);
BrokerageUserRespVO convert(BrokerageUserDO bean);
List<BrokerageUserRespVO> convertList(List<BrokerageUserDO> list);
PageResult<BrokerageUserRespVO> convertPage(PageResult<BrokerageUserDO> page, Map<Long, MemberUserRespDTO> userMap, Map<Long, Long> brokerageUserCountMap, Map<Long, UserBrokerageSummaryRespBO> userOrderSummaryMap);
default PageResult<BrokerageUserRespVO> convertPage(PageResult<BrokerageUserDO> pageResult,
Map<Long, MemberUserRespDTO> userMap,
Map<Long, Long> brokerageUserCountMap,
Map<Long, UserBrokerageSummaryRespBO> userOrderSummaryMap,
Map<Long, BrokerageWithdrawSummaryRespBO> withdrawMap) {
PageResult<BrokerageUserRespVO> result = convertPage(pageResult, userMap, brokerageUserCountMap, userOrderSummaryMap);
for (BrokerageUserRespVO userVO : result.getList()) {
// 用户信息
copyTo(userMap.get(userVO.getId()), userVO);
// 推广用户数量
userVO.setBrokerageUserCount(MapUtil.getInt(brokerageUserCountMap, userVO.getId(), 0));
// 推广订单数量、推广订单金额
Optional<UserBrokerageSummaryRespBO> orderSummaryOptional = Optional.ofNullable(userOrderSummaryMap.get(userVO.getId()));
userVO.setBrokerageOrderCount(orderSummaryOptional.map(UserBrokerageSummaryRespBO::getCount).orElse(0))
.setBrokerageOrderPrice(orderSummaryOptional.map(UserBrokerageSummaryRespBO::getPrice).orElse(0));
// 已提现次数、已提现金额
Optional<BrokerageWithdrawSummaryRespBO> withdrawSummaryOptional = Optional.ofNullable(withdrawMap.get(userVO.getId()));
userVO.setWithdrawCount(withdrawSummaryOptional.map(BrokerageWithdrawSummaryRespBO::getCount).orElse(0))
.setWithdrawPrice(withdrawSummaryOptional.map(BrokerageWithdrawSummaryRespBO::getPrice).orElse(0));
}
return result;
}
default BrokerageUserRespVO copyTo(MemberUserRespDTO source, BrokerageUserRespVO target) {
if (target == null) {
return null;
}
Optional.ofNullable(source).ifPresent(
user -> target.setNickname(user.getNickname()).setAvatar(user.getAvatar()));
return target;
}
default PageResult<AppBrokerageUserRankByUserCountRespVO> convertPage03(PageResult<AppBrokerageUserRankByUserCountRespVO> pageResult,
Map<Long, MemberUserRespDTO> userMap) {
pageResult.getList().forEach(vo -> copyTo(userMap.get(vo.getId()), vo));
return pageResult;
}
void copyTo(MemberUserRespDTO from, @MappingTarget AppBrokerageUserRankByUserCountRespVO to);
default AppBrokerageUserMySummaryRespVO convert(Integer yesterdayPrice, Integer withdrawPrice,
Long firstBrokerageUserCount, Long secondBrokerageUserCount,
BrokerageUserDO brokerageUser) {
AppBrokerageUserMySummaryRespVO respVO = new AppBrokerageUserMySummaryRespVO()
.setYesterdayPrice(ObjUtil.defaultIfNull(yesterdayPrice, 0))
.setWithdrawPrice(ObjUtil.defaultIfNull(withdrawPrice, 0))
.setBrokeragePrice(0).setFrozenPrice(0)
.setFirstBrokerageUserCount(ObjUtil.defaultIfNull(firstBrokerageUserCount, 0L))
.setSecondBrokerageUserCount(ObjUtil.defaultIfNull(secondBrokerageUserCount, 0L));
// 设置 brokeragePrice、frozenPrice 字段
Optional.ofNullable(brokerageUser)
.ifPresent(user -> respVO.setBrokeragePrice(user.getBrokeragePrice()).setFrozenPrice(user.getFrozenPrice()));
return respVO;
}
default void copyTo(List<AppBrokerageUserChildSummaryRespVO> list, Map<Long, MemberUserRespDTO> userMap) {
for (AppBrokerageUserChildSummaryRespVO vo : list) {
Optional.ofNullable(userMap.get(vo.getId())).ifPresent(user ->
vo.setNickname(user.getNickname()).setAvatar(user.getAvatar()));
}
}
}
package org.dromara.mall.convert.trade.brokerage;
import org.dromara.common.dict.utils.DictUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.controller.trade.admin.brokerage.vo.withdraw.BrokerageWithdrawPageReqVO;
import org.dromara.mall.controller.trade.admin.brokerage.vo.withdraw.BrokerageWithdrawRespVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.withdraw.AppBrokerageWithdrawCreateReqVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.withdraw.AppBrokerageWithdrawPageReqVO;
import org.dromara.mall.controller.trade.app.brokerage.vo.withdraw.AppBrokerageWithdrawRespVO;
import org.dromara.mall.domain.trade.BrokerageWithdrawDO;
import org.dromara.mall.enums.trade.DictTypeConstants;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import java.util.Optional;
/**
* 佣金提现 Convert
*
* @author 芋道源码
*/
@Mapper
public interface BrokerageWithdrawConvert {
BrokerageWithdrawConvert INSTANCE = Mappers.getMapper(BrokerageWithdrawConvert.class);
BrokerageWithdrawDO convert(AppBrokerageWithdrawCreateReqVO createReqVO, Long userId, Integer feePrice);
BrokerageWithdrawRespVO convert(BrokerageWithdrawDO bean);
List<BrokerageWithdrawRespVO> convertList(List<BrokerageWithdrawDO> list);
PageResult<BrokerageWithdrawRespVO> convertPage(PageResult<BrokerageWithdrawDO> page);
default PageResult<BrokerageWithdrawRespVO> convertPage(PageResult<BrokerageWithdrawDO> pageResult, Map<Long, MemberUserRespDTO> userMap) {
PageResult<BrokerageWithdrawRespVO> result = convertPage(pageResult);
for (BrokerageWithdrawRespVO vo : result.getList()) {
vo.setUserNickname(Optional.ofNullable(userMap.get(vo.getUserId())).map(MemberUserRespDTO::getNickname).orElse(null));
}
return result;
}
PageResult<AppBrokerageWithdrawRespVO> convertPage02(PageResult<BrokerageWithdrawDO> pageResult);
default PageResult<AppBrokerageWithdrawRespVO> convertPage03(PageResult<BrokerageWithdrawDO> pageResult) {
PageResult<AppBrokerageWithdrawRespVO> result = convertPage02(pageResult);
for (AppBrokerageWithdrawRespVO vo : result.getList()) {
vo.setStatusName(DictUtils.getDictDataLabel(DictTypeConstants.BROKERAGE_WITHDRAW_STATUS, vo.getStatus()));
}
return result;
}
BrokerageWithdrawPageReqVO convert(AppBrokerageWithdrawPageReqVO pageReqVO, Long userId);
}
package org.dromara.mall.convert.trade.cart;
import org.dromara.mall.api.dto.product.ProductSkuRespDTO;
import org.dromara.mall.api.dto.product.ProductSpuRespDTO;
import org.dromara.mall.controller.trade.app.base.sku.AppProductSkuBaseRespVO;
import org.dromara.mall.controller.trade.app.base.spu.AppProductSpuBaseRespVO;
import org.dromara.mall.controller.trade.app.cart.vo.AppCartListRespVO;
import org.dromara.mall.domain.trade.CartDO;
import org.dromara.mall.enums.product.spu.ProductSpuStatusEnum;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
@Mapper
public interface TradeCartConvert {
TradeCartConvert INSTANCE = Mappers.getMapper(TradeCartConvert.class);
default AppCartListRespVO convertList(List<CartDO> carts,
List<ProductSpuRespDTO> spus, List<ProductSkuRespDTO> skus) {
Map<Long, ProductSpuRespDTO> spuMap = convertMap(spus, ProductSpuRespDTO::getId);
Map<Long, ProductSkuRespDTO> skuMap = convertMap(skus, ProductSkuRespDTO::getId);
// 遍历,开始转换
List<AppCartListRespVO.Cart> validList = new ArrayList<>(carts.size());
List<AppCartListRespVO.Cart> invalidList = new ArrayList<>();
carts.forEach(cart -> {
AppCartListRespVO.Cart cartVO = new AppCartListRespVO.Cart();
cartVO.setId(cart.getId()).setCount(cart.getCount()).setSelected(cart.getSelected());
ProductSpuRespDTO spu = spuMap.get(cart.getSpuId());
ProductSkuRespDTO sku = skuMap.get(cart.getSkuId());
cartVO.setSpu(convert(spu)).setSku(convert(sku));
// 如果 SPU 不存在,或者下架,或者库存不足,说明是无效的
if (spu == null
|| !ProductSpuStatusEnum.isEnable(spu.getStatus())
|| spu.getStock() <= 0) {
cartVO.setSelected(false); // 强制设置成不可选中
invalidList.add(cartVO);
} else {
// 虽然 SKU 可能也会不存在,但是可以通过购物车重新选择
validList.add(cartVO);
}
});
return new AppCartListRespVO().setValidList(validList).setInvalidList(invalidList);
}
AppProductSpuBaseRespVO convert(ProductSpuRespDTO spu);
AppProductSkuBaseRespVO convert(ProductSkuRespDTO sku);
}
package org.dromara.mall.convert.trade.config;
import org.dromara.mall.controller.trade.admin.config.vo.TradeConfigRespVO;
import org.dromara.mall.controller.trade.admin.config.vo.TradeConfigSaveReqVO;
import org.dromara.mall.controller.trade.app.config.vo.AppTradeConfigRespVO;
import org.dromara.mall.domain.trade.TradeConfigDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
/**
* 交易中心配置 Convert
*
* @author owen
*/
@Mapper
public interface TradeConfigConvert {
TradeConfigConvert INSTANCE = Mappers.getMapper(TradeConfigConvert.class);
TradeConfigDO convert(TradeConfigSaveReqVO bean);
TradeConfigRespVO convert(TradeConfigDO bean);
AppTradeConfigRespVO convert02(TradeConfigDO tradeConfig);
}
package org.dromara.mall.convert.trade.delivery;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.trade.admin.delivery.vo.express.*;
import org.dromara.mall.controller.trade.app.delivery.vo.express.AppDeliveryExpressRespVO;
import org.dromara.mall.domain.trade.DeliveryExpressDO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public interface DeliveryExpressConvert {
DeliveryExpressConvert INSTANCE = Mappers.getMapper(DeliveryExpressConvert.class);
DeliveryExpressDO convert(DeliveryExpressCreateReqVO bean);
DeliveryExpressDO convert(DeliveryExpressUpdateReqVO bean);
DeliveryExpressRespVO convert(DeliveryExpressDO bean);
List<DeliveryExpressRespVO> convertList(List<DeliveryExpressDO> list);
PageResult<DeliveryExpressRespVO> convertPage(PageResult<DeliveryExpressDO> page);
List<DeliveryExpressExcelVO> convertList02(List<DeliveryExpressDO> list);
List<DeliveryExpressSimpleRespVO> convertList1(List<DeliveryExpressDO> list);
List<AppDeliveryExpressRespVO> convertList03(List<DeliveryExpressDO> list);
}
package org.dromara.mall.convert.trade.delivery;
import cn.hutool.core.collection.CollectionUtil;
import com.google.common.collect.Maps;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.trade.admin.delivery.vo.expresstemplate.*;
import org.dromara.mall.domain.trade.DeliveryExpressTemplateChargeDO;
import org.dromara.mall.domain.trade.DeliveryExpressTemplateDO;
import org.dromara.mall.domain.trade.DeliveryExpressTemplateFreeDO;
import org.dromara.mall.service.trade.delivery.bo.DeliveryExpressTemplateRespBO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Map;
import static org.dromara.common.core.utils.StreamUtils.findFirst;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMultiMap;
@Mapper
public interface DeliveryExpressTemplateConvert {
DeliveryExpressTemplateConvert INSTANCE = Mappers.getMapper(DeliveryExpressTemplateConvert.class);
// ========== Template ==========
DeliveryExpressTemplateDO convert(DeliveryExpressTemplateCreateReqVO bean);
DeliveryExpressTemplateDO convert(DeliveryExpressTemplateUpdateReqVO bean);
DeliveryExpressTemplateRespVO convert(DeliveryExpressTemplateDO bean);
DeliveryExpressTemplateDetailRespVO convert2(DeliveryExpressTemplateDO bean);
List<DeliveryExpressTemplateRespVO> convertList(List<DeliveryExpressTemplateDO> list);
List<DeliveryExpressTemplateSimpleRespVO> convertList1(List<DeliveryExpressTemplateDO> list);
PageResult<DeliveryExpressTemplateRespVO> convertPage(PageResult<DeliveryExpressTemplateDO> page);
default DeliveryExpressTemplateDetailRespVO convert(DeliveryExpressTemplateDO bean,
List<DeliveryExpressTemplateChargeDO> chargeList,
List<DeliveryExpressTemplateFreeDO> freeList) {
DeliveryExpressTemplateDetailRespVO respVO = convert2(bean);
respVO.setCharges(convertTemplateChargeList(chargeList));
respVO.setFrees(convertTemplateFreeList(freeList));
return respVO;
}
// ========== Template Charge ==========
DeliveryExpressTemplateChargeDO convertTemplateCharge(Long templateId, Integer chargeMode, DeliveryExpressTemplateChargeBaseVO vo);
DeliveryExpressTemplateRespBO.Charge convertTemplateCharge(DeliveryExpressTemplateChargeDO bean);
default List<DeliveryExpressTemplateChargeDO> convertTemplateChargeList(Long templateId, Integer chargeMode, List<DeliveryExpressTemplateChargeBaseVO> list) {
return CollectionUtils.convertList(list, vo -> convertTemplateCharge(templateId, chargeMode, vo));
}
// ========== Template Free ==========
DeliveryExpressTemplateFreeDO convertTemplateFree(Long templateId, DeliveryExpressTemplateFreeBaseVO vo);
DeliveryExpressTemplateRespBO.Free convertTemplateFree(DeliveryExpressTemplateFreeDO bean);
List<DeliveryExpressTemplateChargeBaseVO> convertTemplateChargeList(List<DeliveryExpressTemplateChargeDO> list);
List<DeliveryExpressTemplateFreeBaseVO> convertTemplateFreeList(List<DeliveryExpressTemplateFreeDO> list);
default List<DeliveryExpressTemplateFreeDO> convertTemplateFreeList(Long templateId, List<DeliveryExpressTemplateFreeBaseVO> list) {
return CollectionUtils.convertList(list, vo -> convertTemplateFree(templateId, vo));
}
default Map<Long, DeliveryExpressTemplateRespBO> convertMap(Integer areaId, List<DeliveryExpressTemplateDO> templateList,
List<DeliveryExpressTemplateChargeDO> chargeList,
List<DeliveryExpressTemplateFreeDO> freeList) {
Map<Long, List<DeliveryExpressTemplateChargeDO>> templateIdChargeMap = convertMultiMap(chargeList,
DeliveryExpressTemplateChargeDO::getTemplateId);
Map<Long, List<DeliveryExpressTemplateFreeDO>> templateIdFreeMap = convertMultiMap(freeList,
DeliveryExpressTemplateFreeDO::getTemplateId);
// 组合运费模板配置 RespBO
Map<Long, DeliveryExpressTemplateRespBO> result = Maps.newHashMapWithExpectedSize(templateList.size());
templateList.forEach(template -> {
DeliveryExpressTemplateRespBO bo = new DeliveryExpressTemplateRespBO()
.setChargeMode(template.getChargeMode())
.setCharge(convertTemplateCharge(findFirst(templateIdChargeMap.get(template.getId()), charge -> !CollectionUtil.isEmpty(charge.getAreaIds()) && charge.getAreaIds().contains(areaId))))
.setFree(convertTemplateFree(findFirst(templateIdFreeMap.get(template.getId()), free -> !CollectionUtil.isEmpty(free.getAreaIds()) && free.getAreaIds().contains(areaId))));
result.put(template.getId(), bo);
});
return result;
}
}
package org.dromara.mall.convert.trade.delivery;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mall.util.ip.AreaUtils;
import org.dromara.common.mall.util.number.NumberUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.controller.trade.admin.delivery.vo.pickup.DeliveryPickUpStoreCreateReqVO;
import org.dromara.mall.controller.trade.admin.delivery.vo.pickup.DeliveryPickUpStoreRespVO;
import org.dromara.mall.controller.trade.admin.delivery.vo.pickup.DeliveryPickUpStoreSimpleRespVO;
import org.dromara.mall.controller.trade.admin.delivery.vo.pickup.DeliveryPickUpStoreUpdateReqVO;
import org.dromara.mall.controller.trade.app.delivery.vo.pickup.AppDeliveryPickUpStoreRespVO;
import org.dromara.mall.domain.trade.DeliveryPickUpStoreDO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Named;
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public interface DeliveryPickUpStoreConvert {
DeliveryPickUpStoreConvert INSTANCE = Mappers.getMapper(DeliveryPickUpStoreConvert.class);
DeliveryPickUpStoreDO convert(DeliveryPickUpStoreCreateReqVO bean);
DeliveryPickUpStoreDO convert(DeliveryPickUpStoreUpdateReqVO bean);
List<DeliveryPickUpStoreRespVO> convertList(List<DeliveryPickUpStoreDO> list);
PageResult<DeliveryPickUpStoreRespVO> convertPage(PageResult<DeliveryPickUpStoreDO> page);
List<DeliveryPickUpStoreSimpleRespVO> convertList1(List<DeliveryPickUpStoreDO> list);
@Mapping(source = "areaId", target = "areaName", qualifiedByName = "convertAreaIdToAreaName")
DeliveryPickUpStoreSimpleRespVO convert02(DeliveryPickUpStoreDO bean);
@Named("convertAreaIdToAreaName")
default String convertAreaIdToAreaName(Integer areaId) {
return AreaUtils.format(areaId);
}
default List<AppDeliveryPickUpStoreRespVO> convertList(List<DeliveryPickUpStoreDO> list,
Double latitude, Double longitude) {
return CollectionUtils.convertList(list, store -> {
AppDeliveryPickUpStoreRespVO storeVO = convert03(store);
if (latitude != null && longitude != null) {
storeVO.setDistance(NumberUtils.getDistance(latitude, longitude, storeVO.getLatitude(), storeVO.getLongitude()));
}
return storeVO;
});
}
@Mapping(source = "areaId", target = "areaName", qualifiedByName = "convertAreaIdToAreaName")
AppDeliveryPickUpStoreRespVO convert03(DeliveryPickUpStoreDO bean);
}
package org.dromara.mall.convert.trade.order;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import org.dromara.common.core.utils.string.StrUtils;
import org.dromara.common.dict.utils.DictUtils;
import org.dromara.common.mall.util.collection.CollectionUtils;
import org.dromara.common.mall.util.date.DateUtils;
import org.dromara.common.mall.util.ip.AreaUtils;
import org.dromara.common.mybatis.core.page.PageResult;
import org.dromara.mall.api.dto.member.MemberAddressRespDTO;
import org.dromara.mall.api.dto.member.MemberUserRespDTO;
import org.dromara.mall.api.dto.pay.PayOrderCreateReqDTO;
import org.dromara.mall.api.dto.product.*;
import org.dromara.mall.api.dto.promotion.CombinationRecordCreateReqDTO;
import org.dromara.mall.api.dto.trade.TradeOrderRespDTO;
import org.dromara.mall.controller.product.app.property.vo.value.AppProductPropertyValueDetailRespVO;
import org.dromara.mall.controller.trade.admin.base.member.user.MemberUserRespVO;
import org.dromara.mall.controller.trade.admin.base.product.property.ProductPropertyValueDetailRespVO;
import org.dromara.mall.controller.trade.admin.order.vo.*;
import org.dromara.mall.controller.trade.app.order.vo.*;
import org.dromara.mall.controller.trade.app.order.vo.item.AppTradeOrderItemCommentCreateReqVO;
import org.dromara.mall.controller.trade.app.order.vo.item.AppTradeOrderItemRespVO;
import org.dromara.mall.domain.trade.*;
import org.dromara.mall.enums.pay.DictTypeConstants;
import org.dromara.mall.enums.trade.order.TradeOrderItemAfterSaleStatusEnum;
import org.dromara.mall.framework.trade.delivery.core.client.dto.ExpressTrackRespDTO;
import org.dromara.mall.framework.trade.order.config.TradeOrderProperties;
import org.dromara.mall.service.trade.brokerage.bo.BrokerageAddReqBO;
import org.dromara.mall.service.trade.price.bo.TradePriceCalculateReqBO;
import org.dromara.mall.service.trade.price.bo.TradePriceCalculateRespBO;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.Named;
import org.mapstruct.factory.Mappers;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMap;
import static org.dromara.common.mall.util.collection.CollectionUtils.convertMultiMap;
import static org.dromara.common.mall.util.date.LocalDateTimeUtils.addTime;
@Mapper
public interface TradeOrderConvert {
TradeOrderConvert INSTANCE = Mappers.getMapper(TradeOrderConvert.class);
@Mappings({
@Mapping(target = "id", ignore = true),
@Mapping(source = "userId", target = "userId"),
@Mapping(source = "createReqVO.couponId", target = "couponId"),
@Mapping(target = "remark", ignore = true),
@Mapping(source = "createReqVO.remark", target = "userRemark"),
@Mapping(source = "calculateRespBO.price.totalPrice", target = "totalPrice"),
@Mapping(source = "calculateRespBO.price.discountPrice", target = "discountPrice"),
@Mapping(source = "calculateRespBO.price.deliveryPrice", target = "deliveryPrice"),
@Mapping(source = "calculateRespBO.price.couponPrice", target = "couponPrice"),
@Mapping(source = "calculateRespBO.price.pointPrice", target = "pointPrice"),
@Mapping(source = "calculateRespBO.price.vipPrice", target = "vipPrice"),
@Mapping(source = "calculateRespBO.price.payPrice", target = "payPrice")
})
TradeOrderDO convert(Long userId, AppTradeOrderCreateReqVO createReqVO, TradePriceCalculateRespBO calculateRespBO);
TradeOrderRespDTO convert(TradeOrderDO orderDO);
default List<TradeOrderItemDO> convertList(TradeOrderDO tradeOrderDO, TradePriceCalculateRespBO calculateRespBO) {
return CollectionUtils.convertList(calculateRespBO.getItems(), item -> {
TradeOrderItemDO orderItem = convert(item);
orderItem.setOrderId(tradeOrderDO.getId());
orderItem.setUserId(tradeOrderDO.getUserId());
orderItem.setAfterSaleStatus(TradeOrderItemAfterSaleStatusEnum.NONE.getStatus());
orderItem.setCommentStatus(false);
return orderItem;
});
}
TradeOrderItemDO convert(TradePriceCalculateRespBO.OrderItem item);
default ProductSkuUpdateStockReqDTO convert(List<TradeOrderItemDO> list) {
List<ProductSkuUpdateStockReqDTO.Item> items = CollectionUtils.convertList(list, item ->
new ProductSkuUpdateStockReqDTO.Item().setId(item.getSkuId()).setIncrCount(item.getCount()));
return new ProductSkuUpdateStockReqDTO(items);
}
default ProductSkuUpdateStockReqDTO convertNegative(List<TradeOrderItemDO> list) {
List<ProductSkuUpdateStockReqDTO.Item> items = CollectionUtils.convertList(list, item ->
new ProductSkuUpdateStockReqDTO.Item().setId(item.getSkuId()).setIncrCount(-item.getCount()));
return new ProductSkuUpdateStockReqDTO(items);
}
default PayOrderCreateReqDTO convert(TradeOrderDO order, List<TradeOrderItemDO> orderItems,
TradeOrderProperties orderProperties) {
PayOrderCreateReqDTO createReqDTO = new PayOrderCreateReqDTO()
.setAppKey(orderProperties.getPayAppKey()).setUserIp(order.getUserIp());
// 商户相关字段
createReqDTO.setMerchantOrderId(String.valueOf(order.getId()));
String subject = orderItems.get(0).getSpuName();
subject = StrUtils.maxLength(subject, PayOrderCreateReqDTO.SUBJECT_MAX_LENGTH); // 避免超过 32 位
createReqDTO.setSubject(subject);
createReqDTO.setBody(subject); // TODO 芋艿:临时写死
// 订单相关字段
createReqDTO.setPrice(order.getPayPrice()).setExpireTime(addTime(orderProperties.getPayExpireTime()));
return createReqDTO;
}
default PageResult<TradeOrderPageItemRespVO> convertPage(PageResult<TradeOrderDO> pageResult,
List<TradeOrderItemDO> orderItems,
Map<Long, MemberUserRespDTO> memberUserMap) {
Map<Long, List<TradeOrderItemDO>> orderItemMap = convertMultiMap(orderItems, TradeOrderItemDO::getOrderId);
// 转化 List
List<TradeOrderPageItemRespVO> orderVOs = CollectionUtils.convertList(pageResult.getList(), order -> {
List<TradeOrderItemDO> xOrderItems = orderItemMap.get(order.getId());
TradeOrderPageItemRespVO orderVO = convert(order, xOrderItems);
// 处理收货地址
orderVO.setReceiverAreaName(AreaUtils.format(order.getReceiverAreaId()));
// 增加用户信息
orderVO.setUser(convertUser(memberUserMap.get(orderVO.getUserId())));
// 增加推广人信息
orderVO.setBrokerageUser(convertUser(memberUserMap.get(orderVO.getBrokerageUserId())));
return orderVO;
});
return new PageResult<>(orderVOs, pageResult.getTotal());
}
MemberUserRespVO convertUser(MemberUserRespDTO memberUserRespDTO);
TradeOrderPageItemRespVO convert(TradeOrderDO order, List<TradeOrderItemDO> items);
ProductPropertyValueDetailRespVO convert(ProductPropertyValueDetailRespDTO bean);
default TradeOrderDetailRespVO convert(TradeOrderDO order, List<TradeOrderItemDO> orderItems,
List<TradeOrderLogDO> orderLogs,
MemberUserRespDTO user, MemberUserRespDTO brokerageUser) {
TradeOrderDetailRespVO orderVO = convert2(order, orderItems);
// 处理收货地址
orderVO.setReceiverAreaName(AreaUtils.format(order.getReceiverAreaId()));
// 处理用户信息
orderVO.setUser(convert(user));
orderVO.setBrokerageUser(convert(brokerageUser));
// 处理日志
orderVO.setLogs(convertList03(orderLogs));
return orderVO;
}
List<TradeOrderDetailRespVO.OrderLog> convertList03(List<TradeOrderLogDO> orderLogs);
TradeOrderDetailRespVO convert2(TradeOrderDO order, List<TradeOrderItemDO> items);
MemberUserRespVO convert(MemberUserRespDTO bean);
default PageResult<AppTradeOrderPageItemRespVO> convertPage02(PageResult<TradeOrderDO> pageResult,
List<TradeOrderItemDO> orderItems) {
Map<Long, List<TradeOrderItemDO>> orderItemMap = convertMultiMap(orderItems, TradeOrderItemDO::getOrderId);
// 转化 List
List<AppTradeOrderPageItemRespVO> orderVOs = CollectionUtils.convertList(pageResult.getList(), order -> {
List<TradeOrderItemDO> xOrderItems = orderItemMap.get(order.getId());
return convert02(order, xOrderItems);
});
return new PageResult<>(orderVOs, pageResult.getTotal());
}
AppTradeOrderPageItemRespVO convert02(TradeOrderDO order, List<TradeOrderItemDO> items);
AppProductPropertyValueDetailRespVO convert02(ProductPropertyValueDetailRespDTO bean);
default AppTradeOrderDetailRespVO convert02(TradeOrderDO order, List<TradeOrderItemDO> orderItems,
TradeOrderProperties tradeOrderProperties,
DeliveryExpressDO express) {
AppTradeOrderDetailRespVO orderVO = convert3(order, orderItems);
orderVO.setPayExpireTime(DateUtils.of(order.getCreateTime()).plus(tradeOrderProperties.getPayExpireTime()));
if (StrUtil.isNotEmpty(order.getPayChannelCode())) {
orderVO.setPayChannelName(DictUtils.getDictDataLabel(DictTypeConstants.CHANNEL_CODE, order.getPayChannelCode()));
}
// 处理收货地址
orderVO.setReceiverAreaName(AreaUtils.format(order.getReceiverAreaId()));
if (express != null) {
orderVO.setLogisticsId(express.getId()).setLogisticsName(express.getName());
}
return orderVO;
}
AppTradeOrderDetailRespVO convert3(TradeOrderDO order, List<TradeOrderItemDO> items);
AppTradeOrderItemRespVO convert03(TradeOrderItemDO bean);
@Mappings({
@Mapping(target = "skuId", source = "tradeOrderItemDO.skuId"),
@Mapping(target = "orderId", source = "tradeOrderItemDO.orderId"),
@Mapping(target = "orderItemId", source = "tradeOrderItemDO.id"),
@Mapping(target = "descriptionScores", source = "createReqVO.descriptionScores"),
@Mapping(target = "benefitScores", source = "createReqVO.benefitScores"),
@Mapping(target = "content", source = "createReqVO.content"),
@Mapping(target = "picUrls", source = "createReqVO.picUrls"),
@Mapping(target = "anonymous", source = "createReqVO.anonymous"),
@Mapping(target = "userId", source = "tradeOrderItemDO.userId")
})
ProductCommentCreateReqDTO convert04(AppTradeOrderItemCommentCreateReqVO createReqVO, TradeOrderItemDO tradeOrderItemDO);
TradePriceCalculateReqBO convert(AppTradeOrderSettlementReqVO settlementReqVO);
default TradePriceCalculateReqBO convert(Long userId, AppTradeOrderSettlementReqVO settlementReqVO,
List<CartDO> cartList) {
TradePriceCalculateReqBO reqBO = new TradePriceCalculateReqBO().setUserId(userId)
.setItems(new ArrayList<>(settlementReqVO.getItems().size()))
.setCouponId(settlementReqVO.getCouponId()).setPointStatus(settlementReqVO.getPointStatus())
// 物流信息
.setDeliveryType(settlementReqVO.getDeliveryType()).setAddressId(settlementReqVO.getAddressId())
.setPickUpStoreId(settlementReqVO.getPickUpStoreId())
// 各种活动
.setSeckillActivityId(settlementReqVO.getSeckillActivityId())
.setBargainRecordId(settlementReqVO.getBargainRecordId())
.setCombinationActivityId(settlementReqVO.getCombinationActivityId())
.setCombinationHeadId(settlementReqVO.getCombinationHeadId())
.setPointActivityId(settlementReqVO.getPointActivityId());
// 商品项的构建
Map<Long, CartDO> cartMap = convertMap(cartList, CartDO::getId);
for (AppTradeOrderSettlementReqVO.Item item : settlementReqVO.getItems()) {
// 情况一:skuId + count
if (item.getSkuId() != null) {
reqBO.getItems().add(new TradePriceCalculateReqBO.Item().setSkuId(item.getSkuId()).setCount(item.getCount())
.setSelected(true)); // true 的原因,下单一定选中
continue;
}
// 情况二:cartId
CartDO cart = cartMap.get(item.getCartId());
if (cart == null) {
continue;
}
reqBO.getItems().add(new TradePriceCalculateReqBO.Item().setSkuId(cart.getSkuId()).setCount(cart.getCount())
.setCartId(item.getCartId()).setSelected(true)); // true 的原因,下单一定选中
}
return reqBO;
}
default AppTradeOrderSettlementRespVO convert(TradePriceCalculateRespBO calculate, MemberAddressRespDTO address) {
AppTradeOrderSettlementRespVO respVO = convert0(calculate, address);
if (address != null) {
respVO.getAddress().setAreaName(AreaUtils.format(address.getAreaId()));
}
return respVO;
}
AppTradeOrderSettlementRespVO convert0(TradePriceCalculateRespBO calculate, MemberAddressRespDTO address);
List<AppOrderExpressTrackRespDTO> convertList02(List<ExpressTrackRespDTO> list);
TradeOrderDO convert(TradeOrderUpdateAddressReqVO reqVO);
TradeOrderDO convert(TradeOrderUpdatePriceReqVO reqVO);
TradeOrderDO convert(TradeOrderRemarkReqVO reqVO);
default BrokerageAddReqBO convert(MemberUserRespDTO user, TradeOrderItemDO item,
ProductSpuRespDTO spu, ProductSkuRespDTO sku) {
BrokerageAddReqBO bo = new BrokerageAddReqBO().setBizId(String.valueOf(item.getId())).setSourceUserId(item.getUserId())
.setBasePrice(item.getPayPrice())
.setTitle(StrUtil.format("{}成功购买{}", user.getNickname(), item.getSpuName()))
.setFirstFixedPrice(0).setSecondFixedPrice(0);
if (BooleanUtil.isTrue(spu.getSubCommissionType())) {
bo.setFirstFixedPrice(sku.getFirstBrokeragePrice()).setSecondFixedPrice(sku.getSecondBrokeragePrice());
}
return bo;
}
@Named("convertList04")
List<TradeOrderRespDTO> convertList04(List<TradeOrderDO> list);
@Mappings({
@Mapping(target = "activityId", source = "order.combinationActivityId"),
@Mapping(target = "spuId", source = "item.spuId"),
@Mapping(target = "skuId", source = "item.skuId"),
@Mapping(target = "count", source = "item.count"),
@Mapping(target = "orderId", source = "order.id"),
@Mapping(target = "userId", source = "order.userId"),
@Mapping(target = "headId", source = "order.combinationHeadId"),
@Mapping(target = "combinationPrice", source = "item.payPrice"),
})
CombinationRecordCreateReqDTO convert(TradeOrderDO order, TradeOrderItemDO item);
}
package org.dromara.mall.convert.trade.order;
import org.dromara.mall.domain.trade.TradeOrderLogDO;
import org.dromara.mall.service.trade.order.bo.TradeOrderLogCreateReqBO;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;
@Mapper
public interface TradeOrderLogConvert {
TradeOrderLogConvert INSTANCE = Mappers.getMapper(TradeOrderLogConvert.class);
TradeOrderLogDO convert(TradeOrderLogCreateReqBO bean);
}
Markdown 格式
0%
您添加了 0 到此讨论。请谨慎行事。
请先完成此评论的编辑!
注册 或者 后发表评论