msNewPayment2.0/src/main/java/zs/payment/controller/YxSupplyChannelManualController.java

package zs.payment.controller;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.web.bind.annotation.*;
import com.alibaba.fastjson.JSONObject;
import zs.payment.dao.OrderCallbackDao;
import zs.payment.entity.mongodb.supply.OrderCallback;
import zs.payment.enums.CallbackMessageType;
import zs.payment.messages.KafkaProducer;
import zs.payment.req.*;

import zs.payment.req.aftersales.AfterSalesCloseReq;
import zs.payment.req.aftersales.AfterSalesOrderReq;
import zs.payment.req.aftersales.AfterSalesOrderTypeReq;
import zs.payment.resp.Result;

import zs.payment.service.supply.paysupply.PaySupplyService;

import javax.validation.Valid;
import java.util.HashMap;

import java.util.Map;

/**
 * 芸信 供应链平台
 * 售后、物流、支付、回调
 */
@Slf4j
@RestController
@RequestMapping("/supply")
public class YxSupplyChannelManualController {


    @Autowired
    private OrderCallbackDao callbackDao;

    @Autowired
    private PaySupplyService paySupplyService;

    @Autowired
    private KafkaProducer kafkaProducer;

    //订单支付（单独下单之后使用这个支付）
    @PostMapping("/orderPayOnly")
    public Result orderPayOnly(@Valid @RequestBody OrderPayReq req){
        return paySupplyService.orderPayOnly(req);
    }


    // =======================售后==========================================

    /**
     * 获取订单支持的售后方式
     * @param req
     * @return
     */
    @PostMapping("/getAfterSalesTypeNameMap")
    public Result getAfterSalesTypeNameMap(@Valid @RequestBody AfterSalesOrderTypeReq req){

        return paySupplyService.getAfterSalesTypeNameMap(req);
    }


    //申请售后 - 根据订单编号 去创建
    @PostMapping("/afterSalesCreate")
    public Result afterSalesCreate(@Valid @RequestBody AfterSalesOrderReq req){
        return paySupplyService.afterSalesCreate(req);
    }


    //关闭售后
    @PostMapping("/afterSalesClose")
    public Result afterSalesClose(@Valid @RequestBody AfterSalesCloseReq req){
        return paySupplyService.afterSalesClose(req.getId());
    }


    //回调接口，拿到回调数据后，再对数据做处理
    @PostMapping("/callback")
    public Map<String, Object> callback(@Valid @RequestBody Object req) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 0);

        JSONObject reqJson = JSONObject.parseObject(JSONObject.toJSONString(req));
        String messageType = reqJson.getString("message_type");
        OrderCallback callback = new OrderCallback();
        callback.setMessageType(messageType);
        callback.setMessage(req);
        //当 message_type == 商品类的事件 时跳过保存，其他类型才入库
        if (CallbackMessageType.GOODS_ALTER.equalsIgnoreCase(messageType) || CallbackMessageType.GOODS_UNDERCARRIAGE.equalsIgnoreCase(messageType)
        || CallbackMessageType.GOODS_ON_SALE.equalsIgnoreCase(messageType) ||  CallbackMessageType.GOODS_DELETE.equalsIgnoreCase(messageType)) {
            int productId = reqJson.getIntValue("product_id");
            callback.setProductId(productId);
            // 若product_id =0 ,则为无效数据，直接跳过
            if (0== productId){
                return result;
            }
            JSONObject json=new JSONObject();
            json.put("product_id", productId);
            // 商品删除
            if (CallbackMessageType.GOODS_DELETE.equalsIgnoreCase(messageType)){
                //删除商品
                kafkaProducer.sendMessage(CallbackMessageType.GOODS_DELETE, json.toJSONString());
            }
            // 当商品下架的时候，更新商品为下架
            if (CallbackMessageType.GOODS_UNDERCARRIAGE.equalsIgnoreCase(messageType)){
                //更新商品下架，状态变更，
                kafkaProducer.sendMessage(CallbackMessageType.GOODS_UNDERCARRIAGE, json.toJSONString());
            }

            // 当商品上架的时候，若已同步，则更新商品为上架
            if (CallbackMessageType.GOODS_ON_SALE.equalsIgnoreCase(messageType)){

                kafkaProducer.sendMessage(CallbackMessageType.GOODS_ON_SALE, json.toJSONString());
            }

        }

        if (CallbackMessageType.ORDER_DELIVERY.equalsIgnoreCase(messageType)) {
            //订单发货，会传一个第三方订单编号，通过这个第三方订单编号获取物流信息
            String orderSn = reqJson.getString("order_sn");
            if (StringUtils.isNotBlank(orderSn)){
                kafkaProducer.sendMessage(CallbackMessageType.ORDER_DELIVERY, orderSn);
            }
        }

        //售后通过
        if (CallbackMessageType.AFTER_SALES_PASS.equalsIgnoreCase(messageType)) {

        }

        callbackDao.save(callback);

        return result;
    }


    /**
     * 查询商家的收货地址
     * @param req
     * @return
     */
    @PostMapping("/getShopAddress")
    public Result getShopAddress(@Valid @RequestBody OrderPayReq req){
        return paySupplyService.findShopAddressByOrderSn(req.getOrderSn());
    }

    /**
     * 补全退货退款的物流单号
     * @param req
     * @return
     */
    @PostMapping("/afterSalesExpress")
    public Result afterSalesClose(@Valid @RequestBody OrderPayReq  req){
        return paySupplyService.executeAfterSalesExpress(req.getOrderSn());
    }




}