Night-Fragrance/nightFragrance-admin/src/main/java/com/ylx/web/controller/massage/TOrderController.java

package com.ylx.web.controller.massage;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ylx.common.annotation.Log;
import com.ylx.common.core.controller.BaseController;
import com.ylx.common.core.domain.R;
import com.ylx.common.core.domain.model.LoginUser;
import com.ylx.common.enums.BusinessType;
import com.ylx.common.exception.ServiceException;
import com.ylx.common.utils.StringUtils;
import com.ylx.common.utils.poi.ExcelUtil;
import com.ylx.massage.domain.TOrder;
import com.ylx.massage.domain.vo.OrderVerificationVo;
import com.ylx.massage.enums.Enumproject;
import com.ylx.massage.enums.OrderStatusEnum;
import com.ylx.massage.enums.OrderStatusEnumVo;
import com.ylx.massage.service.TOrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;


import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

/**
 * 订单表 前端控制器
 */
@RestController
@Slf4j
@Api(tags = {"订单管理"})
@RequestMapping("api/order/v1")
public class TOrderController extends BaseController {
    @Resource
    private TOrderService orderService;


    /**
     * 下单
     *
     * @param order
     * @return R<TOrder>
     */
    @Log(title = "新增订单", businessType = BusinessType.INSERT)
    @ApiOperation("下单")
    @RequestMapping(value = "wx/add", method = RequestMethod.POST)
    public R<TOrder> add(@RequestBody TOrder order) {
        try {
            return R.ok(orderService.addOrder(order));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    /**
     * 优惠卷核销
     *
     * @param order
     * @return
     */
    @Log(title = "优惠卷核销", businessType = BusinessType.UPDATE)
    @ApiOperation("优惠卷核销")
    @RequestMapping(value = "wx/verification", method = RequestMethod.POST)
    public R<OrderVerificationVo> verification(@RequestBody TOrder order) {
        try {
            return R.ok(orderService.verification(order));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }


    @Log(title = "转单", businessType = BusinessType.INSERT)
    @ApiOperation("转单")
    @RequestMapping(value = "wx/transferOrder", method = RequestMethod.POST)
    public R<TOrder> transferOrder(@RequestBody TOrder order) {
        try {
            return R.ok(orderService.transferOrder(order));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    /**
     * 支付订单
     *
     * @param order
     * @return R
     */
    @ApiOperation("支付订单")
    @Log(title = "支付订单", businessType = BusinessType.UPDATE)
    @RequestMapping(value = "wx/pay", method = RequestMethod.POST)
    public R pay(@RequestBody TOrder order) {
        try {
            return orderService.payOrder(order);
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    /**
     * 取消订单
     *
     * @param order
     * @return R
     */
    @Log(title = "取消订单", businessType = BusinessType.UPDATE)
    @ApiOperation("取消订单")
    @RequestMapping(value = "wx/cancle", method = RequestMethod.POST)
    public R cancle(@RequestBody TOrder order) {
        try {
            return R.ok(orderService.cancle(order));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    /**
     * 拒绝订单
     *
     * @param order
     * @return
     */
    @Log(title = "拒绝订单", businessType = BusinessType.UPDATE)
    @ApiOperation("拒绝订单")
    @RequestMapping(value = "wx/jujue", method = RequestMethod.POST)
    public R jujue(@RequestBody TOrder order) {
        try {
            return R.ok(orderService.jujue(order));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }


    /**
     * 接受订单
     *
     * @param order
     * @return
     */
    @Log(title = "接受订单", businessType = BusinessType.UPDATE)
    @ApiOperation("接受订单")
    @RequestMapping(value = "wx/takingOrders", method = RequestMethod.POST)
    public R takingOrders(@RequestBody TOrder order) {
        try {
            orderService.takingOrders(order);
            return R.ok();
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    @Log(title = "出发", businessType = BusinessType.UPDATE)
    @ApiOperation("出发")
    @RequestMapping(value = "wx/depart", method = RequestMethod.POST)
    public R depart(@RequestBody TOrder order) {
        try {
            orderService.depart(order);
            return R.ok();
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    @Log(title = "到达订单位置", businessType = BusinessType.UPDATE)
    @ApiOperation("到达订单位置")
    @RequestMapping(value = "wx/reach", method = RequestMethod.POST)
    public R reach(@RequestBody TOrder order) {
        try {
            LambdaQueryWrapper<TOrder> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.DEPART.getCode());
            order.setnStatus(OrderStatusEnum.ARRIVED.getCode());
            order.setReachTime(LocalDateTime.now());
            order.setArrivalLatitude(Optional.ofNullable(order.getArrivalLatitude()).orElse(BigDecimal.ZERO));
            order.setArrivalLongitude(Optional.ofNullable(order.getArrivalLongitude()).orElse(BigDecimal.ZERO));
            order.setArrivalPhoto(Optional.ofNullable(order.getArrivalPhoto()).orElse(StringUtils.EMPTY));
            return R.ok(orderService.update(order, wrapper));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    @Log(title = "开始服务", businessType = BusinessType.UPDATE)
    @ApiOperation("开始服务")
    @RequestMapping(value = "wx/service", method = RequestMethod.POST)
    public R service(@RequestBody TOrder order) {
        try {
            LambdaQueryWrapper<TOrder> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.ARRIVED.getCode());
            order.setnStatus(OrderStatusEnum.SERVICE.getCode());
            order.setStartTime(LocalDateTime.now());
            return R.ok(orderService.update(order, wrapper));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    /**
     * 确认订单
     *
     * @param order
     * @return R
     */
    @Log(title = "确认服务完成", businessType = BusinessType.UPDATE)
    @ApiOperation("确认服务完成")
    @RequestMapping(value = "wx/confirm", method = RequestMethod.POST)
    public R confirm(@RequestBody TOrder order) {
        try {
            return R.ok(orderService.confirm(order));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "."
                    + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }

    /**
     * 获取订单信息
     *
     * @param param
     * @return
     */
    @Log(title = "微信获取订单信息", businessType = BusinessType.OTHER)
    @ApiOperation("获取订单信息")
    @RequestMapping(value = "wx/getOrder", method = RequestMethod.GET)
    public R getOrder(Page<TOrder> page, TOrder param) {
        Page<TOrder> all = orderService.getAll(page, param);
        return R.ok(all);
    }

    @Log(title = "技师端-获取待接单数量", businessType = BusinessType.OTHER)
    @ApiOperation("技师端-获取待接单数量")
    @RequestMapping(value = "wx/waitOrder", method = RequestMethod.GET)
    public R waitOrder(@RequestParam String cJsId) {
        List<TOrder> list = orderService.list(new LambdaQueryWrapper<TOrder>().
                eq(TOrder::getnStatus, OrderStatusEnum.WAIT_JD.getCode()).
                eq(TOrder::getcJsId, cJsId));
        return R.ok(list.size());
    }


    /**
     * PC获取订单信息
     *
     * @param page
     * @param order
     * @return R
     */
    @Log(title = "PC获取订单信息", businessType = BusinessType.OTHER)
    @ApiOperation("PC获取订单信息")
    @RequestMapping(value = "pc/getOrder", method = RequestMethod.GET)
    public R getPcOrder(Page<TOrder> page, TOrder order) {
        try {
            LoginUser loginUser = this.getLoginUser();
            log.info("登录用户信息：{}", JSON.toJSONString(loginUser));
            order.setDeptId(loginUser.getDeptId().toString());
            Page<TOrder> all = orderService.getAll(page, order);
            return R.ok(all);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    @Log(title = "微信获取订单信息", businessType = BusinessType.EXPORT)
    @ApiOperation("导出")
    @PostMapping(value = "wx/export")
    public void export(HttpServletResponse response, Page<TOrder> page, TOrder param) {
        Page<TOrder> all = orderService.getAll(page, param);
        ExcelUtil<TOrder> util = new ExcelUtil<>(TOrder.class);
        util.exportExcel(response, all.getRecords(), "订单");
    }

    /**
     * 分页查询订单数据
     *
     * @param page
     * @param order
     * @return R
     */
    @ApiOperation("分页查询订单数据")
    @RequestMapping(value = "/select", method = RequestMethod.GET)
    public R selectSp(Page<TOrder> page, TOrder order) {
        LambdaQueryWrapper<TOrder> tOrderLambdaQueryWrapper = new LambdaQueryWrapper<>();
        tOrderLambdaQueryWrapper.eq(StringUtils.isNotBlank(order.getcJsId()), TOrder::getcJsId, order.getcJsId()).
                eq(StringUtils.isNotBlank(order.getcOpenId()), TOrder::getcOpenId, order.getcOpenId()).
                eq(null != order.getnStatus(), TOrder::getnStatus, order.getnStatus());
        // 获取查询返回结果
        Page<TOrder> pageSelect = orderService.page(page, tOrderLambdaQueryWrapper);
        return R.ok(pageSelect);
    }

    @ApiOperation("更新订单数据")
    @Log(title = "更新订单数据", businessType = BusinessType.OTHER)
    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public R update(@RequestBody TOrder borrow) {
        try {
            return R.ok(orderService.updateAddressById(borrow));
        } catch (ServiceException s) {
            log.error(s.toString());
            return R.fail(s.getMessage());
        } catch (Exception e) {
            StackTraceElement stackTraceElement = e.getStackTrace()[0];
            log.error("系统出错，错误信息:" + e + " at " + stackTraceElement.getClassName() + "."
                    + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber());
            return R.fail("系统异常");
        }
    }


    @ApiOperation("删除数据")
    @RequestMapping(value = "/del", method = RequestMethod.POST)
    public R del(@RequestBody TOrder borrow) {
        return R.ok(orderService.removeById(borrow));
    }

    @ApiOperation("根据id查询")
    @RequestMapping(value = "/getByid", method = RequestMethod.POST)
    public R<TOrder> getByid(@RequestBody TOrder borrow) {
        return R.ok(orderService.getById(borrow.getcId()));
    }

    /**
     * 获取订单状态
     *
     * @return R
     */
    @ApiOperation("订单状态")
    @RequestMapping(value = "/getStatus", method = RequestMethod.GET)
    public R getStatus() {
        List<Enumproject> statusEnum = OrderStatusEnumVo.getStatusEnum();
        return R.ok(statusEnum);
    }
}