dalian-nft-api/src/main/java/modules/order/OrderController.java

package modules.order;

import com.alibaba.fastjson.JSONObject;
import com.jfinal.aop.Before;
import com.jfinal.aop.Inject;
import com.jfinal.kit.StrKit;
import common.interceptor.LoginInterceptor;
import common.interceptor.empty.EmptyInterface;
import common.interceptor.role.RequiredRoleInterface;
import common.model.Nftt;
import common.model.Order;
import common.model.User;
import common.utils.http.MyController;
import common.utils.http.MyRet;
import modules.user.UserController;
import modules.user.UserService;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class OrderController extends MyController {
    @Inject
    private OrderService service;
    @Inject
    private UserService userService;

    public void hello() {
        renderJson(MyRet.ok(service.hello()));
    }

    /**
     * 创建订单调用的接口，会检查库存什么的
     */
    @Before(LoginInterceptor.class)
    @EmptyInterface({"nftt_id"})
    public void create() {
        // --- 从 JSON 请求体中获取参数 ---
        JSONObject requestBodyJson = MyController.getJsonModelByRequestAndType(getRequest(), JSONObject.class);
        Integer nfttId;
        // nfttId
        try {
            nfttId = requestBodyJson.getInteger("nftt_id");
        } catch (Exception e) {
            renderJson(MyRet.fail("你传入的 nftt_id 有些问题：" + e.getMessage()).setData(requestBodyJson));

            return;
        }
        if (nfttId == null) {
            renderJson(MyRet.fail("id(nftt_id) 有问题"));
            return;
        }
        
        // 先判断实名认证过没过
        User user = userService.findUserByMobileNumber(getSessionAttr("mobile_number"));
        if (StrKit.isBlank(user.getHygWorkerId())) {
            renderJson(MyRet.fail("请先进行实名认证"));
            return;
        }
        
        // 获取nftt
        Nftt nftt = Nftt.dao.findById(nfttId);
        if (nftt == null) {
            renderJson(MyRet.fail("nftt不存在"));
            return;
        }
        
        // 过了之后判断当前是预售阶段还是正式开售阶段
        // 判断是否到了预售阶段
        long now = System.currentTimeMillis();
        if (now < nftt.getPresaleStartTime()) {
            renderJson(MyRet.fail("预售未开始，请勿非法请求！"));
            return;
        }
        int orderType = now > nftt.getBuyingStartTime() ? 1 : 0;
        // 执行抢购操作
        renderJson(service.create(nfttId.longValue(), user.getId(), orderType));
    }

//    /**
//     * 用户点击支付时调用的接口
//     */
//    @Before(LoginInterceptor.class)
//    @EmptyInterface({"order_id"})
//    public void paid() {
//        // --- 从 JSON 请求体中获取参数 ---
//        JSONObject requestBodyJson = MyController.getJsonModelByRequestAndType(getRequest(), JSONObject.class);
//        Integer orderId;
//        // orderId
//        try {
//            orderId = requestBodyJson.getInteger("order_id");
//        } catch (Exception e) {
//            renderJson(MyRet.fail("你传入的 order_id 有些问题：" + e.getMessage()).setData(requestBodyJson));
//
//            return;
//        }
//        if (orderId == null) {
//            renderJson(MyRet.fail("id(order_id) 有问题"));
//            return;
//        }
//        User user = userService.findUserByMobileNumber(<String>getSessionAttr("mobile_number"));
//
//        // 判断订单归属权
//        if (service.isOrderBelongToUser(user.getId(), orderId)) {
//            renderJson(MyRet.fail("订单信息错误，再违规请求将封禁ip"));
//            return;
//        }
//
//        // 判断订单状态
//        Order order = Order.dao.findById(orderId);
//        if (order.getOrderStatus() != OrderStatus.PENDING_PAY.code) {
//            renderJson(MyRet.fail("该订单不需要支付，状态：" + order.getOrderStatus()));
//            return;
//        }
//        
//        // 调用支付接口
//        renderJson(MyRet.ok("模拟支付完成"));
//    }
//
//    /**
//     * 慧用工支付回调接口
//     */
//    public void hygPaid() {
//        // 慧用工支付完回调接口，无论成败都要调用该接口
//    }

    /**
     * 用户点击取消时调用的接口
     */
    @Before(LoginInterceptor.class)
    @EmptyInterface({"order_id"})
    public void cancel() {
        // --- 从 JSON 请求体中获取参数 ---
        JSONObject requestBodyJson = MyController.getJsonModelByRequestAndType(getRequest(), JSONObject.class);
        Integer orderId;
        // orderId
        try {
            orderId = requestBodyJson.getInteger("order_id");
        } catch (Exception e) {
            renderJson(MyRet.fail("你传入的 order_id 有些问题：" + e.getMessage()).setData(requestBodyJson));

            return;
        }
        if (orderId == null) {
            renderJson(MyRet.fail("id(order_id) 有问题"));
            return;
        }
        User user = userService.findUserByMobileNumber(getSessionAttr("mobile_number"));
        
        // 判断订单归属权
        if (service.isOrderBelongToUser(user.getId(), orderId)) {
            renderJson(MyRet.fail("订单信息错误，再违规请求将封禁ip"));
            return;
        }

        renderJson(service.cancelByUser(user.getId(), orderId));
    }
    
    @Before(LoginInterceptor.class)
    public void findOrderById() {
        // --- 从 JSON 请求体中获取参数 ---
        JSONObject requestBodyJson = MyController.getJsonModelByRequestAndType(getRequest(), JSONObject.class);
        Integer orderId;
        // orderId
        try {
            orderId = requestBodyJson.getInteger("order_id");
        } catch (Exception e) {
            renderJson(MyRet.fail("你输入的 order_id 有些问题：" + e.getMessage()).setData(requestBodyJson));

            return;
        }
        if (orderId == null) {
            renderJson(MyRet.fail("id(order_id) 有问题"));
            return;
        }
        User user = userService.findUserByMobileNumber(getSessionAttr("mobile_number"));
        
        renderJson(service.findOrderById(orderId, user.getId()));
    }

    /**
     * 用户调用的订单列表
     */
    @Before(LoginInterceptor.class)
    public void orderList() {
        // --- 从 JSON 请求体中获取参数 ---
        JSONObject requestBodyJson = MyController.getJsonModelByRequestAndType(getRequest(), JSONObject.class);
        
        User user = userService.findUserByMobileNumber(getSessionAttr("mobile_number"));

        int status;
        // 使用 Fastjson 的 containsKey 和 get 方法来判断和获取
        if (requestBodyJson.containsKey("status")) {
            // 参数存在，但需要判断其类型和值
            Object statusObj = requestBodyJson.get("status"); // 获取原始 Object

            if (statusObj == null) {
                // 如果 status 字段存在，但值为 JSON null
                status = -1;
            } else if (statusObj instanceof Number) {
                // 如果是数字类型 (Integer, Long, Double 等)，直接获取其整数值
                status = ((Number) statusObj).intValue();
            } else if (statusObj instanceof String) {
                // 如果是字符串类型，尝试进行转换
                String statusStr = (String) statusObj;
                try {
                    status = Integer.parseInt(statusStr);
                } catch (NumberFormatException e) {
                    // 字符串不能转换为数字，报错
                    renderJson(MyRet.fail("你输入的 status 格式不正确，期待一个数字，但却是一个无法解析的字符串: '" + statusStr + "'").setData(requestBodyJson));
                    return;
                }
            } else {
                // 其他不支持的类型 (Boolean, Array, Object)，报错
                renderJson(MyRet.fail("你输入的 status 类型不正确，期待一个数字，却是一个：" + statusObj.getClass().getSimpleName()).setData(requestBodyJson));
                return;
            }
        } else {
            // 如果 status 字段在 JSON 中完全不存在
            status = -1;
        }
        
        renderJson(service.findOrderByUser(user.getId(), status));
    }

    /**
     * 管理员调用的订单列表，包含查询条件，这个得有
     */
    @Before(LoginInterceptor.class)
    @RequiredRoleInterface({UserController.ROLE_SUPER_ADMIN})
    @EmptyInterface({"page_size", "page_number"})
    public void orderListByAdmin() {
        // --- 从 JSON 请求体中获取参数 ---
        JSONObject requestBodyJson = MyController.getJsonModelByRequestAndType(getRequest(), JSONObject.class);
        Integer orderStatus;
        try {
            orderStatus = requestBodyJson.getInteger("order_status");
        } catch (Exception e) {
            renderJson(MyRet.fail("你传入的 order_status 有些问题：" + e.getMessage()).setData(requestBodyJson));

            return;
        }

        // 页面大小
        String pageSizeStr = requestBodyJson.getString("page_size");
        int pageSizeInt;
        try {
            pageSizeInt = Integer.parseInt(pageSizeStr);

            if (pageSizeInt <= 0) {
                renderJson(MyRet.fail("页面大小(page_size)期待是正整数，你传的是: " + pageSizeStr));
                return;
            }
        } catch (Exception e) {
            renderJson(MyRet.fail("页面大小(page_size)格式不正确: " + e.getMessage()));
            return;
        }

        // 页码
        String pageNumberStr = requestBodyJson.getString("page_number");
        int pageNumberInt;
        try {
            pageNumberInt = Integer.parseInt(pageNumberStr);

            if (pageNumberInt <= 0) {
                renderJson(MyRet.fail("页码(page_number)期待是正整数，你传的是: " + pageNumberStr));
                return;
            }
        } catch (Exception e) {
            renderJson(MyRet.fail("页码(page_number)格式不正确: " + e.getMessage()));
            return;
        }
        
        renderJson(service.findForAdmin(pageNumberInt, pageSizeInt, orderStatus));
    }

    /**
     * 管理员更新状态，先不做
     */
    @Before(LoginInterceptor.class)
    @RequiredRoleInterface({UserController.ROLE_CHECK_ADMIN, UserController.ROLE_SUPER_ADMIN})
    public void updateByAdmin() {
        renderJson(MyRet.fail("后端还没做"));
    }

    /**
     * 获取订单的状态码以及对应的状态描述
     */
    @Before(LoginInterceptor.class)
    public void orderStatus() {
        List<Map<String, Object>> statusList = new ArrayList<>();

        for (OrderStatus status : OrderStatus.values()) {
            Map<String, Object> statusMap = new HashMap<>();
            statusMap.put("code", status.code);
            statusMap.put("desc", status.desc);
            statusList.add(statusMap);
        }

        renderJson(MyRet.ok("查询成功").setData(statusList));
    }
    
    // 订单状态枚举 (建议定义在单独的类或枚举中)
    public enum OrderStatus {
        INIT(0, "创建待初始化"),
        // PENDING_PAY(10, "待支付"),
        // PREORDER_PENDING_CONFIRM(20, "预购待确认"), // 预购已支付，等待转换为正式销售
        PREORDER_SUCCESS(30, "预购成功"), // 预购已成功，等待正式销售
        PAID(40, "已支付"), // 正式购买已支付，等待发货
        // DELIVERED(50, "已发货/已确权"),
        COMPLETED(60, "已完成"),
        // REFUNDING(70, "退款中"),
        REFUNDED(80, "退款成功"),
        // REFUND_FAILED(90, "退款失败"),
        CANCELED(100, "已取消");

        public final int code;
        public final String desc;

        OrderStatus(int code, String desc) {
            this.code = code;
            this.desc = desc;
        }
    }

    // 订单类型枚举
    public enum OrderType {
        FORMAL_PURCHASE(1, "正式购买"),
        PREORDER(2, "预购");

        public final int code;
        public final String desc;

        OrderType(int code, String desc) {
            this.code = code;
            this.desc = desc;
        }
    }
}