#feat 订单接口

yanghui

2022-11-11 26c1775b28955943654db1c9effecb17fad2d331

#feat 订单接口

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/model/dtos/shop/PageComFlowerOrderListDTO.java

New file
@@ -0,0 +1,26 @@
package com.panzhihua.common.model.dtos.shop;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * @auther lyq
 * @create 2021-04-14 15:02:14
 * @describe 分页查询订单列表
 */
@Data
@ApiModel("花城分页查询订单列表")
public class PageComFlowerOrderListDTO {

    @ApiModelProperty(value = "分页-当前页数", example = "1")
    private Long pageNum = 1L;
    @ApiModelProperty(value = "分页-每页记录数", example = "10")
    private Long pageSize = 10L;

    @ApiModelProperty(value = "订单状态(1.等待配送 2.配送中 3.待收货 4.待评价 5.已完成 6.已取消 7.已退款)")
    private Integer status;

    @ApiModelProperty(value = "用户id", hidden = true)
    private Long userId;
}

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/model/vos/shop/AddShopFlowerGoodsVO.java

@@ -8,6 +8,7 @@
import javax.validation.Valid;
import javax.validation.constraints.Digits;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import java.math.BigDecimal;
import java.util.List;

@@ -54,4 +55,8 @@
    @ApiModelProperty("商品规格")
    @Valid
    private List<AddShopFlowerGoodsAttrVO> goodsAttrVOList;

    @ApiModelProperty("商品分类")
    @NotEmpty(groups = {AddGroup.class}, message = "商品分类不能为空")
    private List<Long> categoryIds;
}

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/model/vos/shop/ComShopFlowerOrderGoodsVO.java

New file
@@ -0,0 +1,75 @@
package com.panzhihua.common.model.vos.shop;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;

/**
 * @auther lyq
 * @create 2021-04-14 15:02:14
 * @describe 订单预览商品参数
 */
@Data
@ApiModel("订单预览商品参数")
public class ComShopFlowerOrderGoodsVO {

    /**
     * 商品名称
     */
    @ApiModelProperty(value = "商品名称")
    private String goodsName;

    /**
     * 商品图片
     */
    @ApiModelProperty(value = "商品图片")
    private String goodsPic;

    /**
     * 商品价格
     */
    @ApiModelProperty(value = "商品价格")
    private BigDecimal price;

    /**
     * 商品数量
     */
    @ApiModelProperty(value = "商品数量")
    private Integer num;

    /**
     * 商品id
     */
    @ApiModelProperty(value = "商品id")
    private Long goodsId;

    /**
     * 商品规格id
     */
    @ApiModelProperty(value = "商品规格id")
    private Long goodsAttrId;

    /**
     * 商品规格
     */
    @ApiModelProperty(value = "商品规格")
    private String goodsAttr;

    /**
     * 商品状态(1.出售中 2.已下架 3.已删除)
     */
    @ApiModelProperty(value = "商品状态(1.出售中  2.已下架 3.已删除)")
    private Integer goodsStatus = 1;

    /**
     * 商品状态(1.出售中 2.已下架 3.已删除)
     */
    public interface goodsStatus {
        int csz = 1;
        int yxj = 2;
        int ysc = 3;
    }

}

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/model/vos/shop/ComShopFlowerOrderOperateVO.java

New file
@@ -0,0 +1,30 @@
package com.panzhihua.common.model.vos.shop;

import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.util.Date;

@Data
@ApiModel("订单操作日志")
public class ComShopFlowerOrderOperateVO {

    @ApiModelProperty(value = "订单号")
    private String orderNo;

    @ApiModelProperty(value = "操作人")
    private String operationBy;

    @ApiModelProperty(value = "操作时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date operationTime;

    @ApiModelProperty(value = "操作类型(1.创建订单 2.取消订单 3.订单支付 4.订单发货 5.订单完成)")
    private Integer operationType;

    @ApiModelProperty(value = "操作内容")
    private String operationContent;

}

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/model/vos/shop/ComShopFlowerOrderPageVO.java

New file
@@ -0,0 +1,93 @@
package com.panzhihua.common.model.vos.shop;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.panzhihua.common.model.vos.community.convenient.ConvenientMerchantVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

@Data
@ApiModel("订单信息")
public class ComShopFlowerOrderPageVO {

    @ApiModelProperty(value = "订单id")
    private Long orderId;

    @ApiModelProperty(value = "订单号")
    private String orderNo;

    @ApiModelProperty(value = "订单金额")
    private BigDecimal orderTotal;

    @ApiModelProperty(value = "店铺id")
    private Long storeId;

    @ApiModelProperty(value = "订单状态(1.等待配送 2.配送中 3.待收货 4.待评价 5.已完成 6.已取消 7.已退款)")
    private Integer status;

    @ApiModelProperty(value = "支付状态(1.未支付 2.已支付)")
    private Integer payStatus;

    @ApiModelProperty(value = "用户收货地址id")
    private Long receiverId;

    @ApiModelProperty(value = "支付金额")
    private BigDecimal payAmount;

    @ApiModelProperty(value = "配送方式")
    private Integer deliveryType;

    @ApiModelProperty(value = "订单备注")
    private String remark;

    @ApiModelProperty(value = "支付方式（1.微信支付）")
    private Integer payType;

    @ApiModelProperty(value = "支付时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date payTime;

    @ApiModelProperty(value = "订单发货状态（1.未发货  2.已发货）")
    private Integer deliveryStatus;

    @ApiModelProperty(value = "物流公司")
    private String logisticsCompany;

    @ApiModelProperty(value = "物流单号")
    private String logisticsNo;

    @ApiModelProperty(value = "下单时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date createAt;

    @ApiModelProperty(value = "支付单号")
    private String payNo;

    @ApiModelProperty(value = "发货时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date deliveryTime;

    @ApiModelProperty(value = "收货时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date receivingTime;

    @ApiModelProperty(value = "订单下商品信息")
    private List<ComShopFlowerOrderGoodsVO> orderGoodsVOList;

    @ApiModelProperty(value = "订单下店铺信息")
    private ConvenientMerchantVO convenientMerchantVO;

    @ApiModelProperty(value = "用户收货地址id")
    private ComShopUserAddressVO userAddressVO;

    @ApiModelProperty(value = "商品名称")
    private String goodsName;

    @ApiModelProperty(value = "订单日志")
    private List<ComShopFlowerOrderOperateVO> logs;

}

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/model/vos/shop/ComShopFlowerOrderPreviewVO.java

New file
@@ -0,0 +1,44 @@
package com.panzhihua.common.model.vos.shop;

import com.panzhihua.common.model.vos.community.convenient.ConvenientMerchantVO;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;
import java.util.List;

/**
 * @auther lyq
 * @create 2021-04-14 15:02:14
 * @describe 订单预览返回参数
 */
@Data
@ApiModel("订单预览返回参数")
public class ComShopFlowerOrderPreviewVO {

    /**
     * 用户默认收货地址
     */
    @ApiModelProperty(value = "用户默认收货地址")
    private ComShopUserAddressVO userAddressVO;

    /**
     * 店铺信息
     */
    @ApiModelProperty(value = "店铺信息")
    private ConvenientMerchantVO convenientMerchantVO;


    /**
     * 订单总金额
     */
    @ApiModelProperty(value = "订单总金额")
    private BigDecimal orderTotal;

    /**
     * 订单商品总数量
     */
    @ApiModelProperty(value = "订单商品总数量")
    private Integer orderGoodsTotal;
}

 springcloud_k8s_panzhihuazhihuishequ/common/src/main/java/com/panzhihua/common/model/vos/shop/ComShopFlowerOrderVO.java

New file
@@ -0,0 +1,25 @@
package com.panzhihua.common.model.vos.shop;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;

@Data
@ApiModel("订单创建返回参数")
public class ComShopFlowerOrderVO {

    @ApiModelProperty(value = "订单号")
    private String orderNo;

    @ApiModelProperty(value = "订单ID")
    private Long orderId;

    @ApiModelProperty(value = "订单金额")
    private BigDecimal orderTotal;

    @ApiModelProperty(value = "请求支付返回参数")
    private String payResult;

}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/api/ConvenientApi.java

@@ -803,4 +803,13 @@
    public R pageGoodsCategory(@RequestBody PageConvenientGoodsCategoryDTO pageConvenientGoodsCategoryDTO) {
        return convenientGoodsCategoryService.pageGoodsCategory(pageConvenientGoodsCategoryDTO);
    }

    /**
     * 获取所有商品分类
     * @return
     */
    @GetMapping("/goodsCategory/getAllGoodsCategories")
    public R getAllGoodsCategories(){
        return convenientGoodsCategoryService.getAllGoodsCategories();
    }
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/api/ShopFlowerApi.java

@@ -6,6 +6,7 @@
import com.panzhihua.common.model.vos.shop.AddShopFlowerGoodsVO;
import com.panzhihua.common.service.user.UserService;
import com.panzhihua.service_community.service.ComShopFlowerGoodsService;
import com.panzhihua.service_community.service.ConvenientGoodsCategoryService;
import com.panzhihua.service_community.service.ConvenientMerchantService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
@@ -93,6 +94,17 @@
    }

    /**
     * 根据商品id查询商品详情
     *
     * @param goodsId 商品id
     * @return 商品信息
     */
    @PostMapping("shopGoodsDetail")
    public R shopGoodsDetail(@RequestParam("goodsId") Long goodsId) {
        return comShopFlowerGoodsService.shopFlowerGoodsDetail(goodsId);
    }

    /**
     * 修改商品状态
     *
     * @param id
@@ -141,17 +153,6 @@
        return comShopFlowerGoodsService.pageShopGoods(comShopGoodsDTO);
    }

    *//**
     * 根据商品id查询商品详情
     *
     * @param goodsId
     *            商品id
     * @return 商品信息
     *//*
    @PostMapping("shopGoodsDetail")
    public R shopGoodsDetail(@RequestParam("goodsId") Long goodsId) {
        return comShopFlowerGoodsService.shopGoodsDetail(goodsId);
    }

    *//**
     * 根据用户id查询购物车列表

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/dao/ComShopFlowerOrderDAO.java

@@ -1,15 +1,30 @@
package com.panzhihua.service_community.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.panzhihua.common.model.dtos.shop.PageComFlowerOrderListDTO;
import com.panzhihua.common.model.dtos.shop.PageComShopOrderSearchDTO;
import com.panzhihua.common.model.vos.shop.ComShopFlowerOrderPageVO;
import com.panzhihua.common.model.vos.shop.ComShopOrderSearchVO;
import com.panzhihua.service_community.model.dos.ComShopFlowerOrderDO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

/**
 * @ClassName:  ComShopFlowerOrderMapper
 * @ClassName: ComShopFlowerOrderMapper
 * @Author: yh
 * @Date: 2022/11/9 16:46
 * @Description: TODO
 */
@Mapper
public interface ComShopFlowerOrderDAO extends BaseMapper<ComShopFlowerOrderDO> {


    IPage<ComShopFlowerOrderPageVO> pageOrderList(@Param("page") Page page, @Param("comOrderListDTO") PageComFlowerOrderListDTO comOrderListDTO);


    IPage<ComShopOrderSearchVO> pageOrderBy(@Param("page") Page page,
                                            @Param("pageComShopOrderSearchDTO") PageComShopOrderSearchDTO pageComShopOrderSearchDTO);
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/dao/ConvenientGoodsCategoryDAO.java

@@ -31,6 +31,19 @@
            PageConvenientGoodsCategoryDTO pageConvenientGoodsCategoryDTO);

    /**
     * 创建商品、分类关系
     * @param id
     * @param goodsId
     * @param goodsCategoryId
     * @param goodsCategoryName
     * @param createdBy
     * @return
     */
    int createGoodsCategoryRelation(@Param("id")Long id,@Param("goodsId") Long goodsId, @Param("goodsCategoryId") Long goodsCategoryId,
                                      @Param("goodsCategoryName") String goodsCategoryName, @Param("createdBy") Long createdBy);


    /**
     * 删除商家服务类型关系
     * @param goodsId
     * @return

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/model/dos/ComShopFlowerOrderDO.java

@@ -174,4 +174,94 @@
    @TableField(value = "refund_time")
    private Date refundTime;

    /**
     * 自提点id
     */
    private Long pointId;


    /**
     * 订单状态(0.待付款 1.等待配送 2.配送中 3.待收货 4.待评价 5.已完成 6.已取消 7.已退款)
     */
    public interface status {
        int dfk = 0;
        int ddps = 1;
        int psz = 2;
        int dsh = 3;
        int dpj = 4;
        int ywc = 5;
        int yqx = 6;
        int ytk = 7;
    }

    /**
     * 支付状态(1.未支付 2.已支付)
     */
    public interface payStatus {
        int no = 1;
        int yes = 2;
    }

    /**
     * 删除状态(1.未删除 2.已删除)
     */
    public interface deleteStatus {
        int no = 1;
        int yes = 2;
    }

    /**
     * 支付方式（1.微信支付）
     */
    public interface payType {
        int wx = 1;
    }

    /**
     * 配送方式（1.商家配送 2.快递物流）
     */
    public interface deliveryType {
        int store = 1;
        int express = 2;
    }

    /**
     * 订单发货状态（1.未发货 2.已发货）
     */
    public interface deliveryStatus {
        int no = 1;
        int yes = 2;
    }

    @Override
    public String toString() {
        return "ComShopFlowerOrderDO{" +
                "id=" + id +
                ", storeId=" + storeId +
                ", userId=" + userId +
                ", orderNo='" + orderNo + '\'' +
                ", payNo='" + payNo + '\'' +
                ", wxTardeNo='" + wxTardeNo + '\'' +
                ", status=" + status +
                ", payStatus=" + payStatus +
                ", receiverId=" + receiverId +
                ", deleteStatus=" + deleteStatus +
                ", totalAmount=" + totalAmount +
                ", discountAmount=" + discountAmount +
                ", payAmount=" + payAmount +
                ", payType=" + payType +
                ", payTime=" + payTime +
                ", deliveryType=" + deliveryType +
                ", deliveryStatus=" + deliveryStatus +
                ", remark='" + remark + '\'' +
                ", logisticsCompany='" + logisticsCompany + '\'' +
                ", logisticsNo='" + logisticsNo + '\'' +
                ", createAt=" + createAt +
                ", updateAt=" + updateAt +
                ", deliveryTime=" + deliveryTime +
                ", serviceTime=" + serviceTime +
                ", receivingTime=" + receivingTime +
                ", refundTime=" + refundTime +
                '}';
    }
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/model/dos/ComShopFlowerOrderGoodsDO.java

@@ -1,9 +1,6 @@
package com.panzhihua.service_community.model.dos;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;

import java.io.Serializable;
@@ -113,294 +110,6 @@
    /**
     * 创建时间
     */
    @TableField(value = "create_at")
    @TableField(value = "create_at",fill = FieldFill.INSERT)
    private Date createAt;

    /**
     * 获取订单商品id
     *
     * @return id - 订单商品id
     */
    public Long getId() {
        return id;
    }

    /**
     * 设置订单商品id
     *
     * @param id 订单商品id
     */
    public void setId(Long id) {
        this.id = id;
    }

    /**
     * 获取店铺id
     *
     * @return store_id - 店铺id
     */
    public Long getStoreId() {
        return storeId;
    }

    /**
     * 设置店铺id
     *
     * @param storeId 店铺id
     */
    public void setStoreId(Long storeId) {
        this.storeId = storeId;
    }

    /**
     * 获取订单id
     *
     * @return order_id - 订单id
     */
    public Long getOrderId() {
        return orderId;
    }

    /**
     * 设置订单id
     *
     * @param orderId 订单id
     */
    public void setOrderId(Long orderId) {
        this.orderId = orderId;
    }

    /**
     * 获取用户id
     *
     * @return user_id - 用户id
     */
    public Long getUserId() {
        return userId;
    }

    /**
     * 设置用户id
     *
     * @param userId 用户id
     */
    public void setUserId(Long userId) {
        this.userId = userId;
    }

    /**
     * 获取订单号
     *
     * @return order_no - 订单号
     */
    public String getOrderNo() {
        return orderNo;
    }

    /**
     * 设置订单号
     *
     * @param orderNo 订单号
     */
    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }

    /**
     * 获取商品id
     *
     * @return goods_id - 商品id
     */
    public Long getGoodsId() {
        return goodsId;
    }

    /**
     * 设置商品id
     *
     * @param goodsId 商品id
     */
    public void setGoodsId(Long goodsId) {
        this.goodsId = goodsId;
    }

    /**
     * 获取商品规格id
     *
     * @return goods_attr_id - 商品规格id
     */
    public Long getGoodsAttrId() {
        return goodsAttrId;
    }

    /**
     * 设置商品规格id
     *
     * @param goodsAttrId 商品规格id
     */
    public void setGoodsAttrId(Long goodsAttrId) {
        this.goodsAttrId = goodsAttrId;
    }

    /**
     * 获取规格名称
     *
     * @return goods_attr_name - 规格名称
     */
    public String getGoodsAttrName() {
        return goodsAttrName;
    }

    /**
     * 设置规格名称
     *
     * @param goodsAttrName 规格名称
     */
    public void setGoodsAttrName(String goodsAttrName) {
        this.goodsAttrName = goodsAttrName;
    }

    /**
     * 获取购买数量
     *
     * @return amount - 购买数量
     */
    public Integer getAmount() {
        return amount;
    }

    /**
     * 设置购买数量
     *
     * @param amount 购买数量
     */
    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    /**
     * 获取商品规格价格
     *
     * @return goods_attr_price - 商品规格价格
     */
    public BigDecimal getGoodsAttrPrice() {
        return goodsAttrPrice;
    }

    /**
     * 设置商品规格价格
     *
     * @param goodsAttrPrice 商品规格价格
     */
    public void setGoodsAttrPrice(BigDecimal goodsAttrPrice) {
        this.goodsAttrPrice = goodsAttrPrice;
    }

    /**
     * 获取商品规格图
     *
     * @return goods_attr_pic - 商品规格图
     */
    public String getGoodsAttrPic() {
        return goodsAttrPic;
    }

    /**
     * 设置商品规格图
     *
     * @param goodsAttrPic 商品规格图
     */
    public void setGoodsAttrPic(String goodsAttrPic) {
        this.goodsAttrPic = goodsAttrPic;
    }

    /**
     * 获取原价（划线价）
     *
     * @return price - 原价（划线价）
     */
    public BigDecimal getPrice() {
        return price;
    }

    /**
     * 设置原价（划线价）
     *
     * @param price 原价（划线价）
     */
    public void setPrice(BigDecimal price) {
        this.price = price;
    }

    /**
     * 获取包邮价
     *
     * @return free_shipping_price - 包邮价
     */
    public BigDecimal getFreeShippingPrice() {
        return freeShippingPrice;
    }

    /**
     * 设置包邮价
     *
     * @param freeShippingPrice 包邮价
     */
    public void setFreeShippingPrice(BigDecimal freeShippingPrice) {
        this.freeShippingPrice = freeShippingPrice;
    }

    /**
     * 获取拼单价
     *
     * @return collate_price - 拼单价
     */
    public BigDecimal getCollatePrice() {
        return collatePrice;
    }

    /**
     * 设置拼单价
     *
     * @param collatePrice 拼单价
     */
    public void setCollatePrice(BigDecimal collatePrice) {
        this.collatePrice = collatePrice;
    }

    /**
     * 获取商品名称
     *
     * @return goods_name - 商品名称
     */
    public String getGoodsName() {
        return goodsName;
    }

    /**
     * 设置商品名称
     *
     * @param goodsName 商品名称
     */
    public void setGoodsName(String goodsName) {
        this.goodsName = goodsName;
    }

    /**
     * 获取创建时间
     *
     * @return create_at - 创建时间
     */
    public Date getCreateAt() {
        return createAt;
    }

    /**
     * 设置创建时间
     *
     * @param createAt 创建时间
     */
    public void setCreateAt(Date createAt) {
        this.createAt = createAt;
    }
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/model/dos/ComShopFlowerOrderOperateDO.java

@@ -58,5 +58,14 @@
    @TableField(value = "create_at",fill = FieldFill.INSERT)
    private Date createAt;


    /**
     * 操作类型(1.创建订单 2.取消订单 3.订单支付 4.订单发货 5.订单完成)
     */
    public interface operationType {
        int create = 1;
        int cancel = 2;
        int pay = 3;
        int deliver = 4;
        int complete = 5;
    }
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/model/dos/ComShopFlowerOrderPayDO.java

@@ -77,4 +77,11 @@
    @TableField(value = "update_at",fill = FieldFill.UPDATE)
    private Date updateAt;

    /**
     * 支付状态(1.未支付 2.已支付)
     */
    public interface payStatus {
        int no = 1;
        int yes = 2;
    }
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/ComShopFlowerOrderService.java

New file
@@ -0,0 +1,187 @@
package com.panzhihua.service_community.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.panzhihua.common.model.dtos.shop.*;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.service_community.model.dos.ComShopFlowerOrderDO;
import com.panzhihua.service_community.model.dos.ComShopOrderDO;

/**
 * @auther yh
 * @create 2022-11-08 17:25:45
 * @describe 订单表服务类
 */
public interface ComShopFlowerOrderService extends IService<ComShopFlowerOrderDO> {

    /**
     * 分页搜索订单记录
     * 
     * @param pageComShopOrderSearchDTO
     *            分页数据
     * @return 分页订单
     */
    R pageShopOrder(PageComShopOrderSearchDTO pageComShopOrderSearchDTO);

    /**
     * 订单预览
     * 
     * @param orderPreviewDTO
     *            请求参数
     * @return 订单预览数据
     */
    R orderPreview(ComShopOrderPreviewDTO orderPreviewDTO);

    /**
     * 创建订单
     * 
     * @param orderCreateDTO
     *            创建订单请求参数
     * @return 创建结果
     */
    R orderCreate(ComShopOrderCreateDTO orderCreateDTO);

    /**
     * 分页查询用户订单列表
     * 
     * @param comOrderListDTO
     *            请求参数
     * @return 查询结果
     */
    R pageOrderList(PageComFlowerOrderListDTO comOrderListDTO);

    /**
     * 根据订单id查询订单详情
     * 
     * @param orderId
     *            订单id
     * @return 订单详情
     */
    R orderDetail(Long orderId);

    /**
     * 根据订单id取消订单
     * 
     * @param comShopOrderQueryDTO
     *            订单信息
     * @return 取消结果
     */
    R orderCancel(ComShopOrderQueryDTO comShopOrderQueryDTO);

    /**
     * 根据订单id删除订单
     * 
     * @param orderId
     *            订单id
     * @return 删除结果
     */
    R orderDelete(Long orderId);

    /**
     * 根据订单id确认收货
     * 
     * @param orderId
     *            订单id
     * @param phone
     *            手机号
     * @return 确认结果
     */
    R orderConfirm(Long orderId, String phone);

    /**
     * 统计用户订单数量
     * 
     * @param userId
     *            用户id
     * @return 统计结果
     */
    R orderStatistics(Long userId);

    /**
     * 商家资金的订单详情
     * 
     * @param id
     *            订单id
     * @return
     */
    R capitalDetailByStore(Long id);

    /**
     * 订单发货
     * 
     * @param orderShipDTO
     *            订单发货信息
     * @return 发货结果
     */
    R shipOrder(ComShopOrderShipDTO orderShipDTO);

    /**
     * 订单配送
     * 
     * @param orderDeliverDTO
     *            订单信息
     * @return 配送结果
     */
    R deliverOrder(ComShopOrderDeliverDTO orderDeliverDTO);

    /**
     * 订单完成配送
     * 
     * @param orderDeliverDTO
     *            订单信息
     * @return 完成配送结果
     */
    R finishDeliverOrder(ComShopOrderDeliverDTO orderDeliverDTO);

    /**
     * 获取订单导出数据
     * 
     * @param comShopOrderExportDTO
     *            订单导出参数
     * @return 订单数据
     */
    R shopOrderExportData(ComShopOrderExportDTO comShopOrderExportDTO);

    /**
     * 获取资金导出数据
     * 
     * @param comShopFundsExportDTO
     *            资金导出参数
     * @return 资金数据
     */
    R shopOrderFundsExportData(ComShopFundsExportDTO comShopFundsExportDTO);

    /**
     * 获取用户资金信息
     * 
     * @param userId
     *            用户ID
     * @return 统计结果
     */
    R getFundsStat(Long userId);

    /**
     * 获取分页 资金订单数据
     * 
     * @param pageComShopFundsSearchDTO
     *            资金导出参数
     * @return 资金订单数据
     */
    R pageShopFunds(PageComShopFundsSearchDTO pageComShopFundsSearchDTO);

    /**
     * 微信支付订单回调
     * 
     * @param wxPayNotifyOrderDTO
     *            订单支付回调参数
     */
    void wxOrderPayNotify(WxPayNotifyOrderDTO wxPayNotifyOrderDTO);

    /**
     * 用户点击去支付
     * 
     * @param orderPayDTO
     *            请求参数
     * @return 返回支付对象
     */
    R wxPay(OrderPayDTO orderPayDTO);
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/ConvenientGoodsCategoryService.java

@@ -15,7 +15,7 @@
 */
public interface ConvenientGoodsCategoryService extends IService<ConvenientGoodsCategoryDO> {
    /**
     * 便民服务新增分类
     * 商品分类新增
     *
     * @param convenientGoodsCategoryDTO
     * @return 新增结果
@@ -23,7 +23,7 @@
    R addGoodsCategory(ConvenientGoodsCategoryDTO convenientGoodsCategoryDTO);

    /**
     * 便民服务分类编辑
     * 商品分类编辑
     *
     * @param convenientGoodsCategoryDTO
     * @return 修改结果
@@ -31,7 +31,7 @@
    R putGoodsCategory(ConvenientGoodsCategoryDTO convenientGoodsCategoryDTO);

    /**
     * 便民服务分类删除
     * 商品分类删除
     *
     * @param categoryId 便民服务分类id
     * @param operator   操作人员
@@ -40,7 +40,7 @@
    R deleteGoodsCategoryById(Long categoryId, Long operator);

    /**
     * 获取便民服务分类详情
     * 获取商品分类详情
     *
     * @param categoryId 便民服务分类id
     * @return 分类详情
@@ -48,7 +48,7 @@
    R getGoodsCategoryById(Long categoryId);

    /**
     * 分页查询便民服务分类
     * 分页查询商品分类
     *
     * @param pageConvenientGoodsCategoryDTO
     * @return 分类详情
@@ -56,15 +56,10 @@
    R pageGoodsCategory(PageConvenientGoodsCategoryDTO pageConvenientGoodsCategoryDTO);

    /**
     * 获取所有便民服务分类
     * 获取所有商品分类
     *
     * @return
     */
    R getAllGoodsCategories(String areaCode);
    R getAllGoodsCategories();

    /**
     * 获取该社区商家数量大于0的分类
     * @param communityId
     * @return
     */
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/impl/ComShopFlowerGoodsServiceImpl.java

@@ -1,5 +1,6 @@
package com.panzhihua.service_community.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -13,12 +14,16 @@
import com.panzhihua.common.model.vos.community.convenient.ConvenientMerchantVO;
import com.panzhihua.common.model.vos.shop.*;
import com.panzhihua.common.utlis.DifferentLongListUtil;
import com.panzhihua.common.utlis.Snowflake;
import com.panzhihua.common.utlis.StringUtils;
import com.panzhihua.service_community.dao.ComShopFlowerGoodsAttrDAO;
import com.panzhihua.service_community.dao.ComShopFlowerGoodsDAO;
import com.panzhihua.service_community.dao.ConvenientGoodsCategoryDAO;
import com.panzhihua.service_community.dao.ConvenientMerchantDAO;
import com.panzhihua.service_community.model.dos.*;
import com.panzhihua.service_community.service.ComShopFlowerGoodsAttrService;
import com.panzhihua.service_community.service.ComShopFlowerGoodsService;
import com.panzhihua.service_community.service.ConvenientGoodsCategoryService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
@@ -27,6 +32,8 @@
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import static java.util.Objects.nonNull;

/**
 * @ClassName: ComShopFlowerGoodsServiceImpl
@@ -44,6 +51,8 @@
    private ComShopFlowerGoodsAttrDAO shopFlowerGoodsAttrDAO;
    @Resource
    private ConvenientMerchantDAO convenientMerchantDAO;
    @Resource
    private ConvenientGoodsCategoryDAO convenientGoodsCategoryDAO;

    @Override
    public R saveShopFlowerGoods(AddShopFlowerGoodsVO addShopFlowerGoodsVO) {
@@ -62,6 +71,8 @@
        shopGoodsDO.setDetails(addShopFlowerGoodsVO.getDetails());
        int goodsId = this.baseMapper.insert(shopGoodsDO);
        if (goodsId > 0) {

            //保存规格
            ArrayList<ComShopFlowerGoodsAttrDO> goodsAttrDOS = Lists.newArrayList();
            ComShopFlowerGoodsDO goodDO = this.baseMapper.selectById(shopGoodsDO.getId());
            addShopFlowerGoodsVO.getGoodsAttrVOList().forEach(goodsAttr -> {
@@ -86,7 +97,21 @@
            if (goodsAttrDOS.size() > 0) {
                comShopFlowerGoodsAttrService.saveBatch(goodsAttrDOS);
            }

            //保存商品分类
            Long goodId = shopGoodsDO.getId();
            if (nonNull(goodId)) {
                //添加分类
                List<Long> categoryIds = addShopFlowerGoodsVO.getCategoryIds();
                categoryIds.forEach(categoryId -> {
                    ConvenientGoodsCategoryDO convenientGoodsCategoryDO = convenientGoodsCategoryDAO.selectById(categoryId);
                    convenientGoodsCategoryDAO.createGoodsCategoryRelation(Snowflake.getId(),goodId, categoryId,
                            convenientGoodsCategoryDO.getName(), convenientGoodsCategoryDO.getCreatedBy());
                });
            }
        }


        return R.ok();
    }

@@ -114,6 +139,9 @@
                    goodsAttrVOList.add(goodsAttrVO);
                }
                shopGoods.setGoodsAttrs(goodsAttrVOList);
                if (CollUtil.isNotEmpty(goodsAttrDOs)){
                    shopGoods.setGoodsPic(goodsAttrDOs.get(0).getAttrPic());
                }
            });
        }
        return R.ok(comShopStoreVOIPage);
@@ -135,7 +163,6 @@
                List<ComShopFlowerGoodsAttrVO> goodsAttrList = shopFlowerGoodsAttrDAO.getGoodsAttr(goodsVo.getId());
                if (!goodsAttrList.isEmpty()) {
                    ComShopFlowerGoodsAttrVO comShopFlowerGoodsAttrVO = goodsAttrList.get(0);

                    goodsVo.setGoodsAttrList(goodsAttrList);
                    goodsVo.setGoodsPic(comShopFlowerGoodsAttrVO.getAttrPic());
                    goodsVo.setOriginalPrice(comShopFlowerGoodsAttrVO.getPrice());
@@ -161,11 +188,15 @@
        List<ComShopFlowerGoodsAttrVO> goodsAttrList = new ArrayList<>();
        List<ComShopFlowerGoodsAttrDO> goodsAttrDOS =
                shopFlowerGoodsAttrDAO.selectList(new QueryWrapper<ComShopFlowerGoodsAttrDO>().eq("goods_id", goodsId));
        List<String> images = new ArrayList<>();
        goodsAttrDOS.forEach(attrDO -> {
            ComShopFlowerGoodsAttrVO goodsAttrVO = new ComShopFlowerGoodsAttrVO();
            BeanUtils.copyProperties(attrDO, goodsAttrVO);
            String attrPic = attrDO.getAttrPic();
            images.add(attrPic);
            goodsAttrList.add(goodsAttrVO);
        });


        // 查询商品店铺信息
        ConvenientMerchantDO convenientMerchantDO = convenientMerchantDAO.selectById(goodsDO.getStoreId());
@@ -177,6 +208,7 @@
        BeanUtils.copyProperties(goodsDO, shopGoods);
        shopGoods.setGoodsAttrList(goodsAttrList);
        shopGoods.setConvenientMerchantVO(convenientMerchantVO);
        shopGoods.setImages(StringUtils.join(images,","));
        return R.ok(shopGoods);
    }


 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/impl/ComShopFlowerOrderServiceImpl.java

New file
@@ -0,0 +1,919 @@
package com.panzhihua.service_community.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.panzhihua.common.model.dtos.shop.*;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.convenient.ConvenientMerchantVO;
import com.panzhihua.common.model.vos.shop.*;
import com.panzhihua.common.utlis.DateUtils;
import com.panzhihua.common.utlis.OrderNoUtils;
import com.panzhihua.common.utlis.StringUtils;
import com.panzhihua.common.utlis.WxPayUtils;
import com.panzhihua.service_community.dao.*;
import com.panzhihua.service_community.model.dos.*;
import com.panzhihua.service_community.service.ComShopFlowerOrderService;
import com.panzhihua.service_community.service.ComShopOrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

/**
 * @auther lyq
 * @create 2021-04-14 15:03:01
 * @describe 订单表服务实现类
 */
@Slf4j
@Service
public class ComShopFlowerOrderServiceImpl extends ServiceImpl<ComShopFlowerOrderDAO, ComShopFlowerOrderDO>
    implements ComShopFlowerOrderService {

    @Resource
    private ComShopFlowerGoodsDAO comShopGoodsDAO;
    @Resource
    private ComShopFlowerGoodsAttrDAO comShopGoodsAttrDAO;
    @Resource
    private ComShopCartDAO comShopCartDAO;
    @Resource
    private ComShopStoreDAO comShopStoreDAO;
    @Resource
    private ConvenientMerchantDAO convenientMerchantDAO;
    @Resource
    private ComShopFlowerUserAddressDAO comShopUserAddressDAO;
    @Resource
    private ComShopFlowerOrderOperateDAO comShopOrderOperateDAO;
    @Resource
    private ComShopFlowerOrderGoodsDAO comShopOrderGoodsDAO;
    @Resource
    private ComShopFlowerOrderDAO comShopOrderDAO;
    @Resource
    private ComShopFlowerOrderPayDAO comShopOrderPayDAO;
    @Value("${min.app.isTest}")
    private Boolean isTest;
    @Value("${min.app.appid}")
    private String appid;
    @Value("${min.app.payKey}")
    private String payKey;
    @Value("${min.app.mchId}")
    private String mchId;
    @Value("${min.app.notifyUrl}")
    private String notifyUrl;

    public static void main(String[] args) {
        BigDecimal one = BigDecimal.valueOf(Double.valueOf("1") / 100);
        System.out.println();
    }

    /**
     * 订单预览
     *
     * @param orderPreviewDTO
     *            请求参数
     * @return 订单预览数据
     */
    @Override
    public R orderPreview(ComShopOrderPreviewDTO orderPreviewDTO) {

        // 返回参数
        ComShopFlowerOrderPreviewVO orderPreviewVO = new ComShopFlowerOrderPreviewVO();
        // 返回商品列表
        List<ComShopOrderGoodsVO> orderGoodsList = new ArrayList<>();
        Long storeId = 0L;
        BigDecimal orderTotal = BigDecimal.ZERO;
        Integer orderGoodsTotal = 0;
        // 判断提交方式
        if (orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.details)) {// 详情页提交
            // 查询商品信息
            ComShopFlowerGoodsDO goodsDO =
                comShopGoodsDAO.selectOne(new QueryWrapper<ComShopFlowerGoodsDO>().eq("id", orderPreviewDTO.getGoodsId())
                    .eq("status", ComShopGoodsDO.status.sell).eq("delete_status", ComShopGoodsDO.deleteStatus.no));
            if (goodsDO == null) {
                return R.fail("商品已下架或已删除");
            }
            // 设置店铺id
            storeId = goodsDO.getStoreId();

            // 查询商品规格信息
            ComShopFlowerGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderPreviewDTO.getGoodsAttrId());
            if (goodsAttrDO == null) {
                return R.fail("商品规格不存在");
            }

            orderTotal = goodsAttrDO.getPrice().multiply(BigDecimal.valueOf(orderPreviewDTO.getBuyNum()));
            orderGoodsTotal = orderPreviewDTO.getBuyNum();
            // 商品信息赋值
            ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
            orderGoodsVO.setGoodsName(goodsDO.getName());
            orderGoodsVO.setGoodsId(goodsDO.getId());
            orderGoodsVO.setGoodsAttrId(goodsAttrDO.getId());
            orderGoodsVO.setGoodsPic(goodsAttrDO.getAttrPic());
            orderGoodsVO.setPrice(goodsAttrDO.getPrice());
            orderGoodsVO.setNum(orderPreviewDTO.getBuyNum());
            orderGoodsList.add(orderGoodsVO);
        } else if (orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.cart)) {// 购物车提交
            List<ComShopCartDO> cartList = comShopCartDAO.selectBatchIds(orderPreviewDTO.getCartIds());
            if (cartList.isEmpty()) {
                return R.fail("未找到购物车商品信息");
            }
            // 设置店铺id
            storeId = cartList.get(0).getStoreId();
            // 循环遍历购物车商品信息
            for (ComShopCartDO cartDO : cartList) {
                // 商品信息赋值
                ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
                orderGoodsVO.setGoodsId(cartDO.getGoodsId());
                orderGoodsVO.setGoodsAttrId(cartDO.getGoodsAttrId());
                orderGoodsVO.setGoodsPic(cartDO.getGoodsAttrPic());
                orderGoodsVO.setNum(cartDO.getAmount());
                orderGoodsVO.setGoodsName(cartDO.getGoodsName());
                // 查询商品规格
                ComShopFlowerGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(cartDO.getGoodsAttrId());
                if (goodsAttrDO != null) {
                    orderGoodsVO.setPrice(goodsAttrDO.getPrice());
                } else {
                    orderGoodsVO.setPrice(BigDecimal.ZERO);
                }
                orderTotal = orderTotal.add(orderGoodsVO.getPrice().multiply(BigDecimal.valueOf(cartDO.getAmount())));
                orderGoodsTotal += cartDO.getAmount();
                orderGoodsList.add(orderGoodsVO);
            }
        }
        orderPreviewVO.setOrderTotal(orderTotal);
        orderPreviewVO.setOrderGoodsTotal(orderGoodsTotal);

        // 查询店铺信息
        ConvenientMerchantDO convenientMerchantDO = convenientMerchantDAO.selectById(storeId);
        if (convenientMerchantDO != null) {
            ConvenientMerchantVO shopStoreVO = new ConvenientMerchantVO();
            BeanUtils.copyProperties(convenientMerchantDO, shopStoreVO);
            orderPreviewVO.setConvenientMerchantVO(shopStoreVO);
        }

        // 查询默认收货地址
        ComShopFlowerUserAddressDO userDefaultAddressDO =
            comShopUserAddressDAO.selectOne(new QueryWrapper<ComShopFlowerUserAddressDO>().eq("delete_status", 2)
                .eq("user_id", orderPreviewDTO.getUserId()).eq("is_default", ComShopUserAddressDO.isDefault.yes));

        // 查询用户收货地址中的默认地址
        if (userDefaultAddressDO != null) {
            ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
            BeanUtils.copyProperties(userDefaultAddressDO, userAddressVO);
            orderPreviewVO.setUserAddressVO(userAddressVO);
        } else {
            // 查询上次购买记录的收货地址
            // 查询到用户上一笔订单
            List<ComShopFlowerOrderDO> shopOrders = this.baseMapper.selectList(new QueryWrapper<ComShopFlowerOrderDO>()
                .eq("delete_status", 2).eq("user_id", orderPreviewDTO.getUserId()).orderByDesc("create_at"));
            if (shopOrders != null && shopOrders.size() > 0) {
                ComShopFlowerUserAddressDO userAddressDO =
                    comShopUserAddressDAO.selectById(shopOrders.get(0).getReceiverId());
                if (userAddressDO != null) {
                    ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
                    BeanUtils.copyProperties(userAddressDO, userAddressVO);
                    orderPreviewVO.setUserAddressVO(userAddressVO);
                }
            }
        }

        return R.ok(orderPreviewVO);
    }

    /**
     * 创建订单
     *
     * @param orderCreateDTO
     *            创建订单请求参数
     * @return 创建结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public R orderCreate(ComShopOrderCreateDTO orderCreateDTO) {
        // 创建返回参数
        ComShopFlowerOrderVO shopOrderVO = new ComShopFlowerOrderVO();
        // 查询用户收货地址
        ComShopFlowerUserAddressDO userAddressDO = comShopUserAddressDAO.selectById(orderCreateDTO.getReceiverId());
        if (userAddressDO == null || userAddressDO.getDeleteStatus() != 2) {
            return R.fail("收货地址不存在");
        }
        // 用户id
        Long userId = orderCreateDTO.getUserId();
        // 店铺id
        Long storeId = 0L;
        // 生成订单号
        String orderNo = OrderNoUtils.NextOrderNo(userId);
        // 配送方式
        Integer deliveryType = 0;
        // 订单总金额
        BigDecimal orderTotal = BigDecimal.ZERO;
        // 创建订单商品信息
        List<ComShopFlowerOrderGoodsDO> orderGoodsDOList = new ArrayList<>();
        if (!orderCreateDTO.getOrderGoodsList().isEmpty()) {
            for (ComShopOrderCreateGoodsDTO createGoodsDTO : orderCreateDTO.getOrderGoodsList()) {
                // 查询当前商品信息
                ComShopFlowerGoodsDO goodsDO =
                    comShopGoodsDAO.selectOne(new QueryWrapper<ComShopFlowerGoodsDO>().eq("id", createGoodsDTO.getGoodsId())
                        .eq("delete_status", ComShopGoodsDO.deleteStatus.no).eq("status", ComShopGoodsDO.status.sell));
                if (goodsDO == null) {
                    log.error("未查询到商品信息,商品已下架活已删除,商品id" + createGoodsDTO.getGoodsId());
                    continue;
                }
                storeId = goodsDO.getStoreId();
                deliveryType = goodsDO.getDeliveryType();
                ComShopFlowerOrderGoodsDO orderGoodsDO = new ComShopFlowerOrderGoodsDO();
                orderGoodsDO.setGoodsId(goodsDO.getId());
                orderGoodsDO.setGoodsName(goodsDO.getName());
                orderGoodsDO.setStoreId(storeId);
                orderGoodsDO.setUserId(userId);
                orderGoodsDO.setAmount(createGoodsDTO.getNum());
                orderGoodsDO.setOrderNo(orderNo);
                // 查询当前商品规格
                ComShopFlowerGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(createGoodsDTO.getGoodsAttrId());
                if (goodsAttrDO == null) {
                    log.error(
                        "未查询到商品规格信息,商品id" + createGoodsDTO.getGoodsId() + "商品规格id:" + createGoodsDTO.getGoodsAttrId());
                    continue;
                }
                orderGoodsDO.setGoodsAttrId(goodsAttrDO.getId());
                orderGoodsDO.setGoodsAttrPrice(goodsAttrDO.getPrice());
                orderGoodsDO.setPrice(goodsAttrDO.getPrice());
                orderGoodsDO.setCollatePrice(goodsAttrDO.getCollatePrice());
                orderGoodsDO.setFreeShippingPrice(goodsAttrDO.getFreeShippingPrice());
                orderGoodsDO.setGoodsAttrPic(goodsAttrDO.getAttrPic());
                orderGoodsDOList.add(orderGoodsDO);
                // 将商品金额计算到订单总金额
                orderTotal = orderTotal
                    .add(orderGoodsDO.getGoodsAttrPrice().multiply(BigDecimal.valueOf(orderGoodsDO.getAmount())));
            }
        }
        // 如果是购物车提交，需要将购物车内商品移除
        /*if (orderCreateDTO.getSubmitType().equals(ComShopOrderCreateDTO.submitType.cart)) {
            comShopCartDAO.deleteBatchIds(orderCreateDTO.getCartIds());
        }*/
        // 创建订单信息
        ComShopFlowerOrderDO shopOrderDO = new ComShopFlowerOrderDO();
        shopOrderDO.setOrderNo(orderNo);
        shopOrderDO.setStoreId(storeId);
        shopOrderDO.setUserId(userId);
        shopOrderDO.setStatus(ComShopFlowerOrderDO.status.dfk);
        shopOrderDO.setPayStatus(ComShopFlowerOrderDO.payStatus.no);
        shopOrderDO.setReceiverId(orderCreateDTO.getReceiverId());
        shopOrderDO.setDeleteStatus(ComShopFlowerOrderDO.deleteStatus.no);
        shopOrderDO.setTotalAmount(orderTotal);
        shopOrderDO.setDiscountAmount(BigDecimal.ZERO);
        shopOrderDO.setDeliveryType(deliveryType);
        if (StringUtils.isNotEmpty(orderCreateDTO.getRemark())) {
            shopOrderDO.setRemark(orderCreateDTO.getRemark());
        }
        this.baseMapper.insert(shopOrderDO);
        if (!orderGoodsDOList.isEmpty()) {
            orderGoodsDOList.forEach(orderGoods -> {
                orderGoods.setOrderId(shopOrderDO.getId());
                comShopOrderGoodsDAO.insert(orderGoods);
            });
        }
        // 创建订单操作记录
        ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
        orderOperateDO.setOrderNo(orderNo);
        orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.create);
        orderOperateDO.setOperationTime(new Date());
        if (StringUtils.isNotEmpty(orderCreateDTO.getPhone())) {
            orderOperateDO.setOperationContent("用户" + orderCreateDTO.getPhone() + "下单");
            orderOperateDO.setOperationBy("用户" + orderCreateDTO.getPhone());
        } else {
            orderOperateDO.setOperationContent("用户下单");
            orderOperateDO.setOperationBy("用户");
        }
        comShopOrderOperateDAO.insert(orderOperateDO);
        shopOrderVO.setOrderNo(orderNo);
        shopOrderVO.setOrderTotal(orderTotal);
        shopOrderVO.setOrderId(shopOrderDO.getId());

        try {
            BigDecimal money = orderTotal;
            if (isTest) {
                money = BigDecimal.valueOf(0.01);
            }
            // 调用wx支付
            String xml = WxPayUtils.getUnifiedorder(appid, mchId, payKey, notifyUrl, "商品购买", orderCreateDTO.getOpenId(),
                orderNo, money,null);
            log.info("微信支付返回参数:" + xml);
            shopOrderVO.setPayResult(xml);
        } catch (Exception e) {
            log.error("调用微信支付异常,异常原因：" + e.getMessage());
        }
        return R.ok(shopOrderVO);
    }

    /**
     * 分页查询用户订单列表
     *
     * @param comOrderListDTO
     *            请求参数
     * @return 查询结果
     */
    @Override
    public R pageOrderList(PageComFlowerOrderListDTO comOrderListDTO) {
        Page page = new Page<>(comOrderListDTO.getPageNum(), comOrderListDTO.getPageSize());
        IPage<ComShopFlowerOrderPageVO> orderPageVOIPage = this.baseMapper.pageOrderList(page, comOrderListDTO);
        if (!orderPageVOIPage.getRecords().isEmpty()) {
            orderPageVOIPage.getRecords().forEach(orderVo -> {
                List<ComShopFlowerOrderGoodsVO> orderGoodsVOS = new ArrayList<>();
                // 查询订单下商品信息
                List<ComShopFlowerOrderGoodsDO> orderGoodsDOList = comShopOrderGoodsDAO
                    .selectList(new QueryWrapper<ComShopFlowerOrderGoodsDO>().eq("order_no", orderVo.getOrderNo()));
                if (!orderGoodsDOList.isEmpty()) {
                    orderGoodsDOList.forEach(orderGoods -> {
                        ComShopFlowerOrderGoodsVO orderGoodsVO = new ComShopFlowerOrderGoodsVO();
                        BeanUtils.copyProperties(orderGoods, orderGoodsVO);
                        // 根据商品规格id查询商品规格
                        ComShopFlowerGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderGoods.getGoodsAttrId());
                        if (goodsAttrDO != null) {
                            orderGoodsVO.setGoodsAttr(goodsAttrDO.getGoodsAttrName());
                        }
                        orderGoodsVO.setNum(orderGoods.getAmount());
                        orderGoodsVO.setGoodsPic(orderGoods.getGoodsAttrPic());
                        orderGoodsVO.setPrice(orderGoods.getGoodsAttrPrice());
                        orderGoodsVOS.add(orderGoodsVO);
                    });
                }
                orderVo.setOrderGoodsVOList(orderGoodsVOS);

                ConvenientMerchantVO shopStoreVO = new ConvenientMerchantVO();
                // 查询店铺信息
                ConvenientMerchantDO convenientMerchantDO = convenientMerchantDAO.selectById(orderVo.getStoreId());
                if (convenientMerchantDO != null) {
                    BeanUtils.copyProperties(convenientMerchantDO, shopStoreVO);
                }
                orderVo.setConvenientMerchantVO(shopStoreVO);
            });
        }
        return R.ok(orderPageVOIPage);
    }

    /**
     * 根据订单id查询订单详情
     *
     * @param orderId
     *            订单id
     * @return 订单详情
     */
    @Override
    public R orderDetail(Long orderId) {

        ComShopFlowerOrderPageVO orderVO = new ComShopFlowerOrderPageVO();
        // 查询订单信息
        ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        BeanUtils.copyProperties(shopOrderDO, orderVO);
        orderVO.setOrderTotal(shopOrderDO.getTotalAmount());

        ConvenientMerchantVO shopStoreVO = new ConvenientMerchantVO();
        // 查询店铺信息
        ConvenientMerchantDO shopStoreDO = convenientMerchantDAO.selectById(shopOrderDO.getStoreId());
        if (shopStoreDO != null) {
            BeanUtils.copyProperties(shopStoreDO, shopStoreVO);
        }
        orderVO.setConvenientMerchantVO(shopStoreVO);

        List<ComShopFlowerOrderGoodsVO> orderGoodsVOS = new ArrayList<>();
        // 查询订单下商品信息
        List<ComShopFlowerOrderGoodsDO> orderGoodsDOList = comShopOrderGoodsDAO
            .selectList(new QueryWrapper<ComShopFlowerOrderGoodsDO>().eq("order_no", shopOrderDO.getOrderNo()));
        StringBuilder sbr = new StringBuilder();
        if (!orderGoodsDOList.isEmpty()) {
            orderGoodsDOList.forEach(orderGoods -> {
                ComShopFlowerOrderGoodsVO orderGoodsVO = new ComShopFlowerOrderGoodsVO();
                BeanUtils.copyProperties(orderGoods, orderGoodsVO);
                orderGoodsVO.setNum(orderGoods.getAmount());
                orderGoodsVO.setGoodsPic(orderGoods.getGoodsAttrPic());
                orderGoodsVO.setPrice(orderGoods.getGoodsAttrPrice());
                // 查询商品信息判断商品状态
                ComShopFlowerGoodsDO goodsDO = comShopGoodsDAO.selectById(orderGoods.getGoodsId());
                if (goodsDO == null || goodsDO.getDeleteStatus().equals(ComShopFlowerGoodsDO.deleteStatus.yes)
                    || goodsDO.getDeleteStatus().equals(ComShopFlowerGoodsDO.status.recovery)) {
                    orderGoodsVO.setGoodsStatus(ComShopFlowerOrderGoodsVO.goodsStatus.ysc);
                } else if (goodsDO.getStatus().equals(ComShopFlowerGoodsDO.status.lower)) {
                    orderGoodsVO.setGoodsStatus(ComShopFlowerOrderGoodsVO.goodsStatus.yxj);
                } else if (goodsDO.getStatus().equals(ComShopFlowerGoodsDO.status.sell)) {
                    orderGoodsVO.setGoodsStatus(ComShopFlowerOrderGoodsVO.goodsStatus.csz);
                }

                // 根据商品规格id查询商品规格
                ComShopFlowerGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderGoods.getGoodsAttrId());
                if (goodsAttrDO != null) {
                    orderGoodsVO.setGoodsAttr(goodsAttrDO.getGoodsAttrName());
                }
                orderGoodsVOS.add(orderGoodsVO);
                sbr.append(orderGoods.getGoodsName() + " ");
            });
        }
        orderVO.setOrderGoodsVOList(orderGoodsVOS);
        orderVO.setGoodsName(sbr.toString());

        ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
        // 查询用户收货地址
        ComShopFlowerUserAddressDO userAddressDO = comShopUserAddressDAO.selectById(shopOrderDO.getReceiverId());
        if (userAddressDO != null) {
            BeanUtils.copyProperties(userAddressDO, userAddressVO);
            orderVO.setUserAddressVO(userAddressVO);
        }

        // 操作日志
        List<ComShopFlowerOrderOperateDO> listOperLog =
            comShopOrderOperateDAO.selectList(new LambdaQueryWrapper<ComShopFlowerOrderOperateDO>()
                .eq(ComShopFlowerOrderOperateDO::getOrderNo, shopOrderDO.getOrderNo()));
        List<ComShopFlowerOrderOperateVO> listOperLogVO = new ArrayList<>(listOperLog.size());
        listOperLog.forEach(logDO -> {
            ComShopFlowerOrderOperateVO copyVO = new ComShopFlowerOrderOperateVO();
            BeanUtils.copyProperties(logDO, copyVO);
            listOperLogVO.add(copyVO);
        });
        orderVO.setLogs(listOperLogVO);
        return R.ok(orderVO);
    }

    /**
     * 根据订单id取消订单
     *
     * @param comShopOrderQueryDTO
     *            订单信息
     * @return 取消结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public R orderCancel(ComShopOrderQueryDTO comShopOrderQueryDTO) {
        // 查询订单
        ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectById(comShopOrderQueryDTO.getOrderId());
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        if (!shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.ddps)) {
            return R.fail("已配送订单不可取消");
        }
        // 取消订单
        shopOrderDO.setStatus(ComShopFlowerOrderDO.status.yqx);
        if (this.baseMapper.updateById(shopOrderDO) > 0) {
            // 添加订单操作记录
            ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
            orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.cancel);
            orderOperateDO.setOperationTime(new Date());
            if (comShopOrderQueryDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent("管理员" + comShopOrderQueryDTO.getOperUserAccount() + "取消订单");
                orderOperateDO.setOperationBy("用户" + comShopOrderQueryDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent("用户取消订单");
                orderOperateDO.setOperationBy("用户");
            }
            comShopOrderOperateDAO.insert(orderOperateDO);
            return R.ok();
        } else {
            return R.fail("取消订单失败");
        }

    }

    /**
     * 根据订单id删除订单
     *
     * @param orderId
     *            订单id
     * @return 删除结果
     */
    @Override
    public R orderDelete(Long orderId) {
        // 查询订单
        ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        if (!shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.ywc)
            && !shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.yqx)) {
            return R.fail("该订单状态不可删除");
        }

        shopOrderDO.setDeleteStatus(ComShopFlowerOrderDO.deleteStatus.yes);
        if (this.baseMapper.updateById(shopOrderDO) > 0) {
            return R.ok();
        } else {
            return R.fail("取消订单失败");
        }
    }

    /**
     * 根据订单id确认收货
     *
     * @param orderId
     *            订单id
     * @param phone
     *            手机号
     * @return 确认结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public R orderConfirm(Long orderId, String phone) {
        // 查询订单
        ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
        if (shopOrderDO == null) {
            return R.fail("未查询到订单");
        }
        if (!shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.dsh)) {
            return R.fail("该订单状态不可确认收货");
        }
        // 订单确认收货
        shopOrderDO.setStatus(ComShopOrderDO.status.ywc);
        shopOrderDO.setReceivingTime(new Date());
        if (this.baseMapper.updateById(shopOrderDO) > 0) {
            // 添加订单操作记录
            ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
            orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopFlowerOrderOperateDO.operationType.complete);
            orderOperateDO.setOperationTime(new Date());
            if (StringUtils.isNotEmpty(phone)) {
                orderOperateDO.setOperationContent("用户" + phone + "确认收货");
                orderOperateDO.setOperationBy("用户" + phone);
            } else {
                orderOperateDO.setOperationContent("用户确认收货");
                orderOperateDO.setOperationBy("用户");
            }
            comShopOrderOperateDAO.insert(orderOperateDO);
            return R.ok();
        } else {
            return R.fail("确认收货失败");
        }
    }

    /**
     * 统计用户订单数量
     *
     * @param userId
     *            用户id
     * @return 统计结果
     */
    @Override
    public R orderStatistics(Long userId) {
        /*OrderStatisticsVO orderStatisticsVO = new OrderStatisticsVO();
        // 待付款订单数
        Integer paymentNum = 0;
        // 待发货订单数
        Integer deliverNum = 0;
        // 待收货订单数
        Integer receivingNum = 0;
        List<ComShopOrderDO> shopOrderList = this.baseMapper.selectList(new QueryWrapper<ComShopOrderDO>()
            .eq("user_id", userId).eq("delete_status", ComShopOrderDO.deleteStatus.no));
        if (!shopOrderList.isEmpty()) {
            for (ComShopOrderDO orderDO : shopOrderList) {
                if (orderDO.getStatus().equals(ComShopOrderDO.status.dfk)) {
                    paymentNum++;
                } else if (orderDO.getStatus().equals(ComShopOrderDO.status.dfh)) {
                    deliverNum++;
                } else if (orderDO.getStatus().equals(ComShopOrderDO.status.dsh)) {
                    receivingNum++;
                }
            }
        }
        orderStatisticsVO.setPaymentNum(paymentNum);
        orderStatisticsVO.setDeliverNum(deliverNum);
        orderStatisticsVO.setReceivingNum(receivingNum);
        return R.ok(orderStatisticsVO);*/
        return R.ok();
    }

    /**
     * 订单发货
     *
     * @param orderShipDTO
     *            订单发货信息
     * @return 发货结果
     */
    @Override
    public R shipOrder(ComShopOrderShipDTO orderShipDTO) {
        ComShopFlowerOrderDO comShopOrderDO = comShopOrderDAO.selectById(orderShipDTO.getOrderId());
        if (comShopOrderDO == null) {
            return R.fail("订单不存在");
        }
        if (!(comShopOrderDO.getStatus() == 1) || !(comShopOrderDO.getDeliveryStatus() == 1)) {
            return R.fail("订单发货失败,订单状态不允许发货");
        }

      /*  ConvenientMerchantDO convenientMerchantDO = convenientMerchantDAO.selectById(comShopOrderDO.getStoreId());
        if (convenientMerchantDO.getDeliveryType() != 2) {
            return R.fail("该商家不支持通过快递物流发货");
        }*/
        comShopOrderDO.setDeliveryStatus(2);
        comShopOrderDO.setDeliveryType(2);
        comShopOrderDO.setStatus(3);
        comShopOrderDO.setDeliveryTime(Calendar.getInstance().getTime());
        comShopOrderDO.setLogisticsCompany(orderShipDTO.getLogisticsCompany());
        comShopOrderDO.setLogisticsNo(orderShipDTO.getLogisticsNo());
        int updated = comShopOrderDAO.updateById(comShopOrderDO);
        if (updated == 1) {
            // 创建订单操作记录
            ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
            orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopFlowerOrderOperateDO.operationType.deliver);
            orderOperateDO.setOperationTime(new Date());
            if (orderShipDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent(orderShipDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderShipDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent(orderShipDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderShipDTO.getOperUserAccount());
            }
            int inserted = comShopOrderOperateDAO.insert(orderOperateDO);
            if (inserted != 1) {
                log.error("订单发货日志保存错误");
            }
            return R.ok("发货成功");
        }
        return R.fail("发货失败!");
    }

    @Override
    public R deliverOrder(ComShopOrderDeliverDTO orderDeliverDTO) {
        ComShopFlowerOrderDO comShopOrderDO = comShopOrderDAO.selectById(orderDeliverDTO.getOrderId());
        if (comShopOrderDO == null) {
            return R.fail("订单不存在");
        }
        if (!(comShopOrderDO.getStatus() == 2) || !(comShopOrderDO.getDeliveryStatus() == 1)) {
            return R.fail("当前订单不能配送");
        }
        /*ComShopStoreDO storeDO = comShopStoreDAO.selectById(comShopOrderDO.getStoreId());
        if (storeDO.getDeliveryType() != 1) {
            return R.fail("该商家不支持通过商家配送");
        }*/
        comShopOrderDO.setDeliveryStatus(4);
        comShopOrderDO.setDeliveryType(1);
        comShopOrderDO.setStatus(3);
        comShopOrderDO.setDeliveryTime(Calendar.getInstance().getTime());
        int updated = comShopOrderDAO.updateById(comShopOrderDO);
        if (updated == 1) {

            // 创建订单操作记录
            ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
            orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.deliver);
            orderOperateDO.setOperationTime(new Date());
            if (orderDeliverDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent(orderDeliverDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent(orderDeliverDTO.getOperUserAccount() + "已发货");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            }
            int inserted = comShopOrderOperateDAO.insert(orderOperateDO);
            if (inserted != 1) {
                log.error("订单发货日志保存错误");
            }
            return R.ok("开始配送");
        }
        return R.fail("操作失败!");
    }

    @Override
    public R finishDeliverOrder(ComShopOrderDeliverDTO orderDeliverDTO) {
        ComShopFlowerOrderDO comShopOrderDO = comShopOrderDAO.selectById(orderDeliverDTO.getOrderId());
        if (comShopOrderDO == null) {
            return R.fail("订单不存在");
        }
        if (comShopOrderDO.getDeliveryStatus() != 4 && comShopOrderDO.getDeliveryStatus() != 3) {
            return R.fail("订单还未开始配送");
        }
        if (!(comShopOrderDO.getStatus() == 3)) {
            return R.fail("订单还未发货");
        }
        // comShopOrderDO.setStatus(4);
        comShopOrderDO.setDeliveryStatus(5);
        int updated = comShopOrderDAO.updateById(comShopOrderDO);
        if (updated == 1) {
            // 创建订单操作记录
            ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
            orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
            orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.complete);
            orderOperateDO.setOperationTime(new Date());
            if (orderDeliverDTO.getIsAdmin()) {
                orderOperateDO.setOperationContent("订单已完成");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            } else {
                orderOperateDO.setOperationContent("订单已完成");
                orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
            }
            int inserted = comShopOrderOperateDAO.insert(orderOperateDO);
            if (inserted != 1) {
                log.error("订单发货日志保存错误");
            }
            return R.ok("配送完成");
        }
        return R.fail("操作失败!");
    }

    @Override
    public R shopOrderExportData(ComShopOrderExportDTO comShopOrderExportDTO) {
//        Page page = new Page();
//        page.setSize(10000);
//        page.setCurrent(1);
//        IPage<ExcelShopOrderDTO> excelShopOrderDTO = comShopOrderDAO.selectOrderExport(page, comShopOrderExportDTO);
        return R.ok();
    }

    @Override
    public R shopOrderFundsExportData(ComShopFundsExportDTO comShopFundsExportDTO) {
//        Page page = new Page();
//        page.setSize(10000);
//        page.setCurrent(1);
//        IPage<ExcelShopFundsDTO> excelShopFundsDTO = comShopOrderDAO.selectFundsExport(page, comShopFundsExportDTO);
        return R.ok(null);
    }

    @Override
    public R getFundsStat(Long userId) {
       /* ComShopFundsVO comShopFundsVO = comShopOrderDAO.queryStatis(userId);
        if (comShopFundsVO == null) {
            comShopFundsVO = new ComShopFundsVO();
            comShopFundsVO.setMonthTotal(new BigDecimal(0));
            comShopFundsVO.setTodayTotal(new BigDecimal(0));
            comShopFundsVO.setWeekTotal(new BigDecimal(0));
        }*/
        return R.ok();
    }

    @Override
    public R pageShopFunds(PageComShopFundsSearchDTO pageComShopFundsSearchDTO) {
        /*Long pageNum = pageComShopFundsSearchDTO.getPageNum();
        Long pageSize = pageComShopFundsSearchDTO.getPageSize();
        Page page = new Page();
        if (pageNum == null || 0 == pageNum.longValue()) {
            pageNum = 1l;
        }
        if (pageSize == null || 0 == pageSize.longValue()) {
            pageSize = 10l;
        }
        page.setCurrent(pageNum);
        page.setSize(pageSize);
        IPage<ComShopFundsOrderVO> comShopFundsOrderVOIPage =
            comShopOrderDAO.pageShopFunds(page, pageComShopFundsSearchDTO);*/
        return R.ok();
    }

    @Override
    public R pageShopOrder(PageComShopOrderSearchDTO pageComShopOrderSearchDTO) {
        Long pageNum = pageComShopOrderSearchDTO.getPageNum();
        Long pageSize = pageComShopOrderSearchDTO.getPageSize();
        Page page = new Page();

        page.setCurrent(pageNum);
        page.setSize(pageSize);
        if (pageNum == null || 0 == pageNum.longValue()) {
            page.setCurrent(1l);
        }
        if (pageSize == null || 0 == pageSize.longValue()) {
            page.setSize(10l);
        }

        IPage<ComShopOrderSearchVO> ipage = this.baseMapper.pageOrderBy(page, pageComShopOrderSearchDTO);
        return R.ok(ipage);
    }

    @Override
    public R capitalDetailByStore(Long id) {
        /*if (id == null) {
            R.fail("订单号不能为空！");
        }
        CapitalDetailVO vo = this.baseMapper.capitalDetailByStore(id);*/
        return R.ok();
    }

    /**
     * 微信支付订单回调
     *
     * @param wxPayNotifyOrderDTO
     *            订单支付回调参数
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void wxOrderPayNotify(WxPayNotifyOrderDTO wxPayNotifyOrderDTO) {
        log.info("微信订单支付回调开始处理逻辑");
        if (StringUtils.isEmpty(wxPayNotifyOrderDTO.getOrderTradeNo())) {
            log.error("微信支付回调失败，订单号为空");
            return;
        }

        log.info("微信订单支付回调开始查询订单");
        // 查询订单
        ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectOne(new QueryWrapper<ComShopFlowerOrderDO>().lambda()
            .eq(ComShopFlowerOrderDO::getOrderNo, wxPayNotifyOrderDTO.getOrderTradeNo()));
        if (shopOrderDO == null) {
            log.error("未查询到支付订单,订单回调失败,订单号:" + wxPayNotifyOrderDTO.getOrderTradeNo());
            return;
        }
        shopOrderDO.setStatus(ComShopFlowerOrderDO.status.ddps);
        shopOrderDO.setPayType(ComShopFlowerOrderDO.payType.wx);
        shopOrderDO.setPayStatus(ComShopFlowerOrderDO.payStatus.yes);
        shopOrderDO.setPayAmount(BigDecimal.valueOf(Double.valueOf(wxPayNotifyOrderDTO.getCashFee()) / 100));
        shopOrderDO.setWxTardeNo(wxPayNotifyOrderDTO.getWxTradeNo());
        shopOrderDO.setPayTime(
            DateUtils.stringToDate(wxPayNotifyOrderDTO.getPayTime(), new SimpleDateFormat("yyyyMMddHHmmss")));
        this.baseMapper.updateById(shopOrderDO);

        // 查询订单商品
        List<ComShopFlowerOrderGoodsDO> orderGoodsList =
            comShopOrderGoodsDAO.selectList(new QueryWrapper<ComShopFlowerOrderGoodsDO>().lambda()
                .eq(ComShopFlowerOrderGoodsDO::getOrderNo, shopOrderDO.getOrderNo()));
        if (!orderGoodsList.isEmpty()) {
            int goodsNub = 0;
            for (ComShopFlowerOrderGoodsDO orderGood : orderGoodsList) {
                goodsNub += orderGood.getAmount();
                // 更新商品信息
                ComShopFlowerGoodsDO goodsDO = comShopGoodsDAO.selectById(orderGood.getGoodsId());
                if (goodsDO != null) {
                    goodsDO.setSale(goodsDO.getSale() + orderGood.getAmount());
                    comShopGoodsDAO.updateById(goodsDO);
                }

                // 更新商品规格
                ComShopFlowerGoodsAttrDO goodsAttrDO = comShopGoodsAttrDAO.selectById(orderGood.getGoodsAttrId());
                if (goodsAttrDO != null) {
                    goodsAttrDO.setSale(goodsAttrDO.getSale() + orderGood.getAmount());
                    comShopGoodsAttrDAO.updateById(goodsAttrDO);
                }
            }

            // 更新店铺销量以及销售额
            ComShopStoreDO storeDO = comShopStoreDAO.selectById(shopOrderDO.getStoreId());
            if (storeDO != null) {
                storeDO.setSale(storeDO.getSale() + goodsNub);
                storeDO.setSaleVolume(storeDO.getSaleVolume().add(shopOrderDO.getTotalAmount()));
                comShopStoreDAO.updateById(storeDO);
            }
        }

        // 添加订单操作记录
        ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
        orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
        orderOperateDO.setOperationType(ComShopFlowerOrderOperateDO.operationType.pay);
        orderOperateDO.setOperationTime(new Date());
        orderOperateDO.setOperationContent("用户支付订单");
        orderOperateDO.setOperationBy("用户");
        comShopOrderOperateDAO.insert(orderOperateDO);

        // 添加订单支付记录表
        ComShopFlowerOrderPayDO orderPayDO = new ComShopFlowerOrderPayDO();
        orderPayDO.setOrderNo(shopOrderDO.getOrderNo());
        orderPayDO.setOrderAmount(shopOrderDO.getTotalAmount());
        orderPayDO.setWxTradeNo(wxPayNotifyOrderDTO.getWxTradeNo());
        orderPayDO.setPayStatus(ComShopFlowerOrderPayDO.payStatus.yes);
        orderPayDO.setPayAmount(shopOrderDO.getPayAmount());
        orderPayDO.setPayTime(shopOrderDO.getPayTime());
        comShopOrderPayDAO.insert(orderPayDO);
    }

    /**
     * 订单去支付
     *
     * @param orderPayDTO
     *            请求参数
     * @return 支付对象
     */
    public R wxPay(OrderPayDTO orderPayDTO) {
        // 创建返回参数
        ComShopFlowerOrderVO shopOrderVO = new ComShopFlowerOrderVO();
        // 查询订单
        ComShopFlowerOrderDO orderDO = comShopOrderDAO.selectOne(
            new QueryWrapper<ComShopFlowerOrderDO>().lambda().eq(ComShopFlowerOrderDO::getOrderNo, orderPayDTO.getOrderNo()));
        if (orderDO == null) {
            return R.fail("订单不存在");
        }
        try {
            BigDecimal money = orderDO.getTotalAmount();
            if (isTest) {
                money = BigDecimal.valueOf(0.01);
            }
            // 调用wx支付
            String xml = WxPayUtils.getUnifiedorder(appid, mchId, payKey, notifyUrl, "商品购买", orderPayDTO.getOpenId(),
                orderDO.getOrderNo(), money,null);
            log.info("微信支付返回参数:" + xml);
            shopOrderVO.setPayResult(xml);
        } catch (Exception e) {
            log.error("调用微信支付异常,异常原因：" + e.getMessage());
        }
        shopOrderVO.setOrderId(orderDO.getId());
        shopOrderVO.setOrderNo(orderDO.getOrderNo());
        shopOrderVO.setOrderTotal(orderDO.getTotalAmount());
        return R.ok(shopOrderVO);
    }
}

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/java/com/panzhihua/service_community/service/impl/ConvenientGoodsCategoryServiceImpl.java

@@ -110,10 +110,10 @@
    }

    @Override
    public R getAllGoodsCategories(String areaCode) {
    public R getAllGoodsCategories() {
        List<ConvenientGoodsCategoryVO> categoryVOList = new ArrayList<>();
        List<ConvenientGoodsCategoryDO> categoryDOS = this.baseMapper.selectList(new QueryWrapper<ConvenientGoodsCategoryDO>()
                .lambda().eq(ConvenientGoodsCategoryDO::getAreaCode,areaCode).orderByDesc(ConvenientGoodsCategoryDO::getWeight));
                .lambda().eq(ConvenientGoodsCategoryDO::getIsDel,0).orderByDesc(ConvenientGoodsCategoryDO::getWeight));
        if (!ObjectUtils.isEmpty(categoryDOS)) {
            categoryDOS.forEach(categoryDO -> {
                ConvenientGoodsCategoryVO categoryVO = new ConvenientGoodsCategoryVO();

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/resources/mapper/ComShopFlowerOrderDAO.xml

@@ -1,41 +1,103 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.panzhihua.service_community.dao.ComShopFlowerOrderDAO">
  <resultMap id="BaseResultMap" type="com.panzhihua.service_community.model.dos.ComShopFlowerOrderDO">
    <!--@mbg.generated-->
    <!--@Table com_shop_flower_order-->
    <id column="id" jdbcType="BIGINT" property="id" />
    <result column="store_id" jdbcType="BIGINT" property="storeId" />
    <result column="user_id" jdbcType="BIGINT" property="userId" />
    <result column="order_no" jdbcType="VARCHAR" property="orderNo" />
    <result column="pay_no" jdbcType="VARCHAR" property="payNo" />
    <result column="wx_tarde_no" jdbcType="VARCHAR" property="wxTardeNo" />
    <result column="status" jdbcType="TINYINT" property="status" />
    <result column="pay_status" jdbcType="TINYINT" property="payStatus" />
    <result column="receiver_id" jdbcType="BIGINT" property="receiverId" />
    <result column="delete_status" jdbcType="TINYINT" property="deleteStatus" />
    <result column="total_amount" jdbcType="DECIMAL" property="totalAmount" />
    <result column="discount_amount" jdbcType="DECIMAL" property="discountAmount" />
    <result column="pay_amount" jdbcType="DECIMAL" property="payAmount" />
    <result column="pay_type" jdbcType="TINYINT" property="payType" />
    <result column="pay_time" jdbcType="TIMESTAMP" property="payTime" />
    <result column="delivery_type" jdbcType="TINYINT" property="deliveryType" />
    <result column="delivery_status" jdbcType="TINYINT" property="deliveryStatus" />
    <result column="remark" jdbcType="VARCHAR" property="remark" />
    <result column="logistics_company" jdbcType="VARCHAR" property="logisticsCompany" />
    <result column="logistics_no" jdbcType="VARCHAR" property="logisticsNo" />
    <result column="create_at" jdbcType="TIMESTAMP" property="createAt" />
    <result column="update_at" jdbcType="TIMESTAMP" property="updateAt" />
    <result column="delivery_time" jdbcType="TIMESTAMP" property="deliveryTime" />
    <result column="service_time" jdbcType="TIMESTAMP" property="serviceTime" />
    <result column="receiving_time" jdbcType="TIMESTAMP" property="receivingTime" />
    <result column="refund_time" jdbcType="TIMESTAMP" property="refundTime" />
  </resultMap>
  <sql id="Base_Column_List">
    <!--@mbg.generated-->
    id, store_id, user_id, order_no, pay_no, wx_tarde_no, `status`, pay_status, receiver_id, 
    delete_status, total_amount, discount_amount, pay_amount, pay_type, pay_time, delivery_type, 
    delivery_status, remark, logistics_company, logistics_no, create_at, update_at, delivery_time, 
    service_time, receiving_time, refund_time
  </sql>
    <resultMap id="BaseResultMap" type="com.panzhihua.service_community.model.dos.ComShopFlowerOrderDO">
        <!--@mbg.generated-->
        <!--@Table com_shop_flower_order-->
        <id column="id" jdbcType="BIGINT" property="id"/>
        <result column="store_id" jdbcType="BIGINT" property="storeId"/>
        <result column="user_id" jdbcType="BIGINT" property="userId"/>
        <result column="order_no" jdbcType="VARCHAR" property="orderNo"/>
        <result column="pay_no" jdbcType="VARCHAR" property="payNo"/>
        <result column="wx_tarde_no" jdbcType="VARCHAR" property="wxTardeNo"/>
        <result column="status" jdbcType="TINYINT" property="status"/>
        <result column="pay_status" jdbcType="TINYINT" property="payStatus"/>
        <result column="receiver_id" jdbcType="BIGINT" property="receiverId"/>
        <result column="delete_status" jdbcType="TINYINT" property="deleteStatus"/>
        <result column="total_amount" jdbcType="DECIMAL" property="totalAmount"/>
        <result column="discount_amount" jdbcType="DECIMAL" property="discountAmount"/>
        <result column="pay_amount" jdbcType="DECIMAL" property="payAmount"/>
        <result column="pay_type" jdbcType="TINYINT" property="payType"/>
        <result column="pay_time" jdbcType="TIMESTAMP" property="payTime"/>
        <result column="delivery_type" jdbcType="TINYINT" property="deliveryType"/>
        <result column="delivery_status" jdbcType="TINYINT" property="deliveryStatus"/>
        <result column="remark" jdbcType="VARCHAR" property="remark"/>
        <result column="logistics_company" jdbcType="VARCHAR" property="logisticsCompany"/>
        <result column="logistics_no" jdbcType="VARCHAR" property="logisticsNo"/>
        <result column="create_at" jdbcType="TIMESTAMP" property="createAt"/>
        <result column="update_at" jdbcType="TIMESTAMP" property="updateAt"/>
        <result column="delivery_time" jdbcType="TIMESTAMP" property="deliveryTime"/>
        <result column="service_time" jdbcType="TIMESTAMP" property="serviceTime"/>
        <result column="receiving_time" jdbcType="TIMESTAMP" property="receivingTime"/>
        <result column="refund_time" jdbcType="TIMESTAMP" property="refundTime"/>
    </resultMap>
    <sql id="Base_Column_List">
        <!--@mbg.generated-->
        id, store_id, user_id, order_no, pay_no, wx_tarde_no, `status`, pay_status, receiver_id,
        delete_status, total_amount, discount_amount, pay_amount, pay_type, pay_time, delivery_type,
        delivery_status, remark, logistics_company, logistics_no, create_at, update_at, delivery_time,
        service_time, receiving_time, refund_time
    </sql>

    <select id="pageOrderList" resultType="com.panzhihua.common.model.vos.shop.ComShopFlowerOrderPageVO">
        select id as orderId,order_no,store_id,`status`,pay_status,receiver_id,total_amount as
        orderTotal,pay_amount,delivery_type,remark,create_at from com_shop_flower_order as cso where 1=1 and
        cso.delete_status = 1
        and cso.user_id = #{comOrderListDTO.userId} <if test='comOrderListDTO.status != null'>AND cso.status =
        #{comOrderListDTO.status}
    </if>   order by create_at desc
    </select>

    <select id="pageOrderBy" resultType="com.panzhihua.common.model.vos.shop.ComShopOrderSearchVO">
        SELECT distinct sr.id, sr.store_id, sr.user_id, su.phone AS userName , sr.order_no, sr.pay_no,
        sr.wx_tarde_no, sr.status, sr.pay_status, sr.receiver_id,
        sr.total_amount, sr.discount_amount, sr.pay_amount, sr.pay_type,
        sr.pay_time, sr.delivery_type, sr.delivery_status, sr.logistics_company,
        sr.logistics_no, sr.create_at, uad.name as receiver_name, uad.phone as receiver_phone,
        group_concat(og.goods_name)
        as goodsName, ss.name as store_name
        FROM com_shop_flower_order sr LEFT JOIN com_shop_flower_order_goods og ON sr.id = og.order_id
        LEFT JOIN com_shop_flower_goods_attr ga ON og.goods_attr_id = ga.id
        LEFT JOIN sys_user su ON sr.user_id = su.user_id
        LEFT JOIN com_shop_flower_user_address uad ON sr.receiver_id = uad.id
        LEFT JOIN com_convenient_merchants ss ON sr.store_id = ss.id
        WHERE sr.delete_status = 1
        <if test='pageComShopOrderSearchDTO.userId != null'>
            AND sr.user_id = #{pageComShopOrderSearchDTO.userId}
        </if>
        <if test='pageComShopOrderSearchDTO.createAtStart != null'>
            AND #{pageComShopOrderSearchDTO.createAtStart} <![CDATA[<=]]>  sr.create_at
        </if>
        <if test='pageComShopOrderSearchDTO.createAtEnd != null'>
            AND sr.create_at <![CDATA[<=]]> #{pageComShopOrderSearchDTO.createAtEnd}
        </if>
        <if test='pageComShopOrderSearchDTO.orderNo != null  '>
            AND sr.order_no like concat('%',#{pageComShopOrderSearchDTO.orderNo}, '%')
        </if>
        <if test='pageComShopOrderSearchDTO.userAccount != null  '>
            AND su.phone like concat('%',#{pageComShopOrderSearchDTO.userAccount}, '%')
        </if>
        <if test='pageComShopOrderSearchDTO.receiverAccount != null  '>
            AND uad.name like concat('%',#{pageComShopOrderSearchDTO.receiverAccount}, '%')
        </if>
        <if test='pageComShopOrderSearchDTO.receiverPhone != null '>
            AND uad.phone like concat('%',#{pageComShopOrderSearchDTO.receiverPhone}, '%')
        </if>
        <if test='pageComShopOrderSearchDTO.goodsName != null'>
            AND og.goods_name like concat('%',#{pageComShopOrderSearchDTO.goodsName}, '%')
        </if>
        <if test='pageComShopOrderSearchDTO.status != null '>
            AND sr.status = #{pageComShopOrderSearchDTO.status}
        </if>
        <if test='pageComShopOrderSearchDTO.storeName != null '>
            AND ss.name like concat('%',#{pageComShopOrderSearchDTO.storeName}, '%')
        </if>
        <if test='pageComShopOrderSearchDTO.storeId != null '>
            AND ss.id = #{pageComShopOrderSearchDTO.storeId}
        </if>
        <if test='pageComShopOrderSearchDTO.storeUserId != null '>
            AND ss.sys_user_id = #{pageComShopOrderSearchDTO.storeUserId}
        </if>
        GROUP BY sr.id ORDER BY sr.create_at DESC
    </select>
</mapper>

 springcloud_k8s_panzhihuazhihuishequ/service_community/src/main/resources/mapper/ConvenientGoodsCategoryMapper.xml

@@ -47,5 +47,9 @@
    <select id="checkCategoryIsUsing" resultType="java.lang.Integer">
        SELECT COUNT(1) FROM com_convenient_goods_scope WHERE goods_category_id = #{categoryId}
    </select>
    <insert id="createGoodsCategoryRelation">
        INSERT INTO com_convenient_goods_scope (id,goods_id, goods_category_id, goods_category_name, created_by, created_at)
        VALUES (#{id},#{goodsId}, #{goodsCategoryId}, #{goodsCategoryName}, #{createdBy}, NOW())
    </insert>

</mapper>