package com.agentdriving.driver.modular.system.api;

import com.agentdriving.driver.core.util.ToolUtil;
import com.agentdriving.driver.modular.system.service.*;
import com.agentdriving.driver.modular.system.warpper.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.agentdriving.driver.modular.system.model.Driver;
import com.agentdriving.driver.modular.system.model.Edition;
import com.agentdriving.driver.modular.system.model.JoiningRequirements;
import com.agentdriving.driver.modular.system.util.PayMoneyUtil;
import com.agentdriving.driver.modular.system.util.huawei.OBSUtil;
import com.agentdriving.driver.modular.system.util.huawei.SMSUtil;
import com.agentdriving.driver.modular.system.util.RedisUtil;
import com.agentdriving.driver.modular.system.util.ResultUtil;
import com.agentdriving.driver.modular.system.util.UUIDUtil;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
* 司机控制器
* @author pzb
* @Date 2023/2/3 14:10
*/
@RestController
@RequestMapping("")
public class DriverController {

    @Autowired
    private IBranchOfficeService branchOfficeService;

    @Autowired
    private IDriverService driverService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private IJoiningRequirementsService joiningRequirementsService;

    @Autowired
    private IAccountChangeDetailService accountChangeDetailService;

    @Autowired
    private IYouTuiDriverService youTuiDriverService;

    @Autowired
    private IRevenueService revenueService;

    @Autowired
    private IOrderService orderService;

    @Autowired
    private ICashWithdrawalService cashWithdrawalService;

    @Autowired
    private ISystemConfigService systemConfigService;

    @Autowired
    private PayMoneyUtil payMoneyUtil;

    @Autowired
    private IEditionService editionService;

    @Autowired
    private IDriverBankService driverBankService;

    @Autowired
    private IAgentService agentService;





    @ResponseBody
    @PostMapping("/base/driver/queryCityList")
//    @ServiceLog(name = "获取开通的省市数据", url = "/base/driver/queryCityList")
    @ApiOperation(value = "获取开通的省市数据", tags = {"司机端-登录注册"}, notes = "")
    @ApiImplicitParams({
    })
    public ResponseWarpper<List<OpenCityWarpper>> queryCityList(){
        try {
            List<OpenCityWarpper> list = agentService.queryOpenCity();
            return ResponseWarpper.success(list);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }




    @ResponseBody
    @PostMapping("/base/driver/queryOpenDistrict")
//    @ServiceLog(name = "根据城市code获取开通区域", url = "/base/driver/queryOpenDistrict")
    @ApiOperation(value = "根据城市code获取开通区域", tags = {"司机端-登录注册"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "城市code", name = "cityCode", required = true, dataType = "string"),
    })
    public ResponseWarpper<List<OpenCityWarpper>> queryOpenDistrict(String cityCode){
        if(ToolUtil.isEmpty(cityCode)){
            return ResponseWarpper.success(ResultUtil.paranErr("cityCode"));
        }
        try {
            List<OpenCityWarpper> list = branchOfficeService.queryOpenDistrict(cityCode);
            return ResponseWarpper.success(list);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }




    @ResponseBody
    @PostMapping("/base/driver/driverRegister")
//    @ServiceLog(name = "司机注册申请", url = "/base/driver/driverRegister")
    @ApiOperation(value = "司机注册申请", tags = {"司机端-登录注册"}, notes = "")
    @ApiImplicitParams({
    })
    public ResponseWarpper driverRegister(DriverRegisterWarpper driverRegisterWarpper){
        try {
            ResultUtil resultUtil = driverService.driverRegister(driverRegisterWarpper);
            return ResponseWarpper.success(resultUtil);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }




    @ResponseBody
    @PostMapping("/base/driver/getVerificationCode")
//    @ServiceLog(name = "获取短信验证码", url = "/base/driver/getVerificationCode")
    @ApiOperation(value = "获取短信验证码", tags = {"司机端-登录注册"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "国家代码+86", name = "receiver", required = true, dataType = "string"),
            @ApiImplicitParam(value = "电话号码", name = "phone", required = true, dataType = "string"),
            @ApiImplicitParam(value = "1=登录，2=注册", name = "type", required = true, dataType = "int"),
    })
    public ResponseWarpper getVerificationCode(String receiver, String phone, Integer type){
        if(ToolUtil.isEmpty(receiver)){
            return ResponseWarpper.success(ResultUtil.paranErr("receiver"));
        }
        if(ToolUtil.isEmpty(phone)){
            return ResponseWarpper.success(ResultUtil.paranErr("phone"));
        }
        try {
            if(type == 1){
                Driver driver = driverService.selectOne(new EntityWrapper<Driver>().eq("phone", phone).ne("status", 3));
                if(null == driver){
                    return ResponseWarpper.success(ResultUtil.error("账号未注册"));
                }
                if(driver.getApprovalStatus() == 1){
                    return ResponseWarpper.success(ResultUtil.error("账号正在审核中"));
                }
                if(driver.getApprovalStatus() == 3){
                    return ResponseWarpper.success(ResultUtil.error("账号审核未通过"));
                }
                if(driver.getStatus() == 2){
                    return ResponseWarpper.success(ResultUtil.error("账号已冻结"));
                }
            }
            String numberRandom = UUIDUtil.getNumberRandom(5);
            SMSUtil.send(phone, "4d18e74a95ca400d802755fe0f903589", "[\"" + numberRandom + "\"]");
            redisUtil.setStrValue(receiver + phone, numberRandom, 300);//5分钟有效期
            return ResponseWarpper.success(ResultUtil.success());
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }




    @ResponseBody
    @PostMapping("/base/driver/driverCodeLogin")
//    @ServiceLog(name = "司机短信验证码登录", url = "/base/driver/driverCodeLogin")
    @ApiOperation(value = "司机短信验证码登录", tags = {"司机端-登录注册"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "国家代码+86", name = "receiver", required = true, dataType = "string"),
            @ApiImplicitParam(value = "电话号码", name = "phone", required = true, dataType = "string"),
            @ApiImplicitParam(value = "短信验证码", name = "code", required = true, dataType = "string"),
    })
    public ResponseWarpper<TokenWarpper> driverCodeLogin(String receiver, String phone, String code){
        if(ToolUtil.isEmpty(receiver)){
            return ResponseWarpper.success(ResultUtil.paranErr("receiver"));
        }
        if(ToolUtil.isEmpty(phone)){
            return ResponseWarpper.success(ResultUtil.paranErr("phone"));
        }
        try {
            ResultUtil<TokenWarpper> tokenWarpper = driverService.driverLogin(receiver, phone, code);
            return ResponseWarpper.success(tokenWarpper);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/base/driver/driverPassLogin")
//    @ServiceLog(name = "司机密码登录", url = "/base/driver/driverPassLogin")
    @ApiOperation(value = "司机密码登录", tags = {"司机端-登录注册"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "国家代码+86", name = "receiver", required = true, dataType = "string"),
            @ApiImplicitParam(value = "电话号码", name = "phone", required = true, dataType = "string"),
            @ApiImplicitParam(value = "密码", name = "password", required = true, dataType = "string"),
    })
    public ResponseWarpper<TokenWarpper> driverPassLogin(String receiver, String phone, String password){
        if(ToolUtil.isEmpty(receiver)){
            return ResponseWarpper.success(ResultUtil.paranErr("receiver"));
        }
        if(ToolUtil.isEmpty(phone)){
            return ResponseWarpper.success(ResultUtil.paranErr("phone"));
        }
        if(ToolUtil.isEmpty(password)){
            return ResponseWarpper.success(ResultUtil.paranErr("password"));
        }
        try {
            ResultUtil<TokenWarpper> tokenWarpper = driverService.driverPassLogin(receiver, phone, password);
            return ResponseWarpper.success(tokenWarpper);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



//    @ResponseBody
//    @PostMapping("/api/driver/flushedToken")
//    @ServiceLog(name = "刷新token", url = "/api/driver/flushedToken")
//    @ApiOperation(value = "刷新token", tags = {"司机端-登录注册"}, notes = "")
//    @ApiImplicitParams({
//            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
//    })
//    public ResponseWarpper<TokenWarpper> flushedToken(){
//        try {
//            Integer uid = driverService.getUserByRequest();
//            if(null == uid){
//                return ResponseWarpper.tokenErr();
//            }
//            ResultUtil<TokenWarpper> tokenWarpper = driverService.flushedToken(uid);
//            return ResponseWarpper.success(tokenWarpper);
//        }catch (Exception e){
//            e.printStackTrace();
//            return new ResponseWarpper(500, e.getMessage());
//        }
//    }



    @ResponseBody
    @PostMapping("/api/driver/setPassword")
//    @ServiceLog(name = "司机设置密码", url = "/api/driver/setPassword")
    @ApiOperation(value = "司机设置密码", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "密码", name = "password", required = true, dataType = "string"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper setPassword(String password){
        if(ToolUtil.isEmpty(password)){
            return ResponseWarpper.success(ResultUtil.paranErr("password"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            driverService.setPassword(uid, password);
            return ResponseWarpper.success();
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/queryDriverPosition")
//    @ServiceLog(name = "获取5公里范围内的司机", url = "/api/driver/queryDriverPosition")
    @ApiOperation(value = "获取5公里范围内的司机", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<List<String>> queryDriverPosition(){
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            ResultUtil<List<String>> listResultUtil = driverService.queryDriverPosition(uid);
            return ResponseWarpper.success(listResultUtil);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }





    @ResponseBody
    @PostMapping("/base/driver/addDriverPosition")
//    @ServiceLog(name = "存储司机实时位置", url = "/base/driver/addDriverPosition")
    public ResponseWarpper addDriverPosition(DriverPositionWarpper driverPositionWarpper) {
        try {
            driverService.addDriverPosition(driverPositionWarpper);
            return ResponseWarpper.success();
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/queryPromotionQRCode")
//    @ServiceLog(name = "获取司机推广二维码", url = "/api/driver/queryPromotionQRCode")
    @ApiOperation(value = "获取司机推广二维码", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<PromotionWarpper> queryPromotionQRCode() {
        try {
            Integer uid = driverService.getUserByRequest();
            if (null == uid) {
                return ResponseWarpper.tokenErr();
            }
            PromotionWarpper promotionWarpper = driverService.queryPromotionQRCode(uid);
            return ResponseWarpper.success(promotionWarpper);
        } catch (Exception e) {
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/base/driver/queryJoiningRequirements")
//    @ServiceLog(name = "获取加盟要求", url = "/base/driver/queryJoiningRequirements")
    @ApiOperation(value = "获取加盟要求", tags = {"司机端-登录注册"}, notes = "")
    @ApiImplicitParams({
    })
    public ResponseWarpper<List<String>> queryJoiningRequirements(){
        try {
            List<JoiningRequirements> joiningRequirements = joiningRequirementsService.selectList(new EntityWrapper<JoiningRequirements>().eq("status", 1).orderBy("sort"));
            List<String> collect = joiningRequirements.stream().map(JoiningRequirements::getContent).collect(Collectors.toList());
            return ResponseWarpper.success(collect);
        } catch (Exception e) {
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/queryDriverInfo")
//    @ServiceLog(name = "获取司机个人信息", url = "/api/driver/queryDriverInfo")
    @ApiOperation(value = "获取司机个人信息", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<DriverInfoWarpper> queryDriverInfo(){
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            DriverInfoWarpper driverInfo = driverService.queryDriverInfo(uid);
            return ResponseWarpper.success(driverInfo);
        } catch (Exception e) {
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }




    @ResponseBody
    @PostMapping("/api/driver/saveDriverInfo")
//    @ServiceLog(name = "修改司机个人信息", url = "/api/driver/saveDriverInfo")
    @ApiOperation(value = "修改司机个人信息", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper saveDriverInfo(DriverInfo driverInfo){
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            ResultUtil resultUtil = driverService.saveDriverInfo(uid, driverInfo);
            return ResponseWarpper.success(resultUtil);
        } catch (Exception e) {
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/queryDriverIntegralIncomeAndExpenses")
//    @ServiceLog(name = "获取积分收支明细", url = "/api/driver/queryDriverIntegralIncomeAndExpenses")
    @ApiOperation(value = "获取积分收支明细", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "类型（1=获取，2=消耗）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "pageSize", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<List<IntegralIncomeAndExpensesWarpper>> queryDriverIntegralIncomeAndExpenses(Integer type, Integer pageNum, Integer pageSize){
        if(null == pageNum){
            return ResponseWarpper.success(ResultUtil.paranErr("pageNum"));
        }
        if(null == pageSize){
            return ResponseWarpper.success(ResultUtil.paranErr("pageSize"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            List<IntegralIncomeAndExpensesWarpper> integralIncomeAndExpensesWarppers = accountChangeDetailService.queryDriverIntegralIncomeAndExpenses(uid, type, pageNum, pageSize);
            return ResponseWarpper.success(integralIncomeAndExpensesWarppers);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/queryDriverYouTuiList")
//    @ServiceLog(name = "获取积分兑换记录", url = "/api/driver/queryDriverYouTuiList")
    @ApiOperation(value = "获取积分兑换记录", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<List<DriverYouTuiWarpper>> queryDriverYouTuiList(){
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            List<DriverYouTuiWarpper> driverYouTuiWarppers = youTuiDriverService.queryDriverYouTuiList1(uid);
            return ResponseWarpper.success(driverYouTuiWarppers);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/api/driver/queryCommissionList")
//    @ServiceLog(name = "获取佣金记录", url = "/api/driver/queryCommissionList")
    @ApiOperation(value = "获取佣金记录", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "日期", name = "time", required = true, dataType = "string"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "pageSize", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<List<CommissionListWarpper>> queryCommissionList(String time, Integer pageNum, Integer pageSize){
        if(null == pageNum){
            return ResponseWarpper.success(ResultUtil.paranErr("pageNum"));
        }
        if(null == pageSize){
            return ResponseWarpper.success(ResultUtil.paranErr("pageSize"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            List<CommissionListWarpper> list = revenueService.queryCommissionList(uid, time, pageNum, pageSize);
            return ResponseWarpper.success(list);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/queryInviteList")
//    @ServiceLog(name = "获取司机邀请列表", url = "/api/driver/queryInviteList")
    @ApiOperation(value = "获取司机邀请列表", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "日期", name = "time", required = true, dataType = "string"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "pageSize", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<List<InviteListWarpper>> queryInviteList(String time, Integer pageNum, Integer pageSize){
        if(null == pageNum){
            return ResponseWarpper.success(ResultUtil.paranErr("pageNum"));
        }
        if(null == pageSize){
            return ResponseWarpper.success(ResultUtil.paranErr("pageSize"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            List<InviteListWarpper> inviteListWarppers = orderService.queryInviteList(uid, time, pageNum, pageSize);
            return ResponseWarpper.success(inviteListWarppers);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/queryCommissionDetail")
//    @ServiceLog(name = "获取司机佣金明细", url = "/api/driver/queryCommissionDetail")
    @ApiOperation(value = "获取司机佣金明细", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "日期", name = "time", required = true, dataType = "string"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "pageSize", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<CommissionDetailListWarpper> queryCommissionDetail(String time, Integer pageNum, Integer pageSize){
        if(null == pageNum){
            return ResponseWarpper.success(ResultUtil.paranErr("pageNum"));
        }
        if(null == pageSize){
            return ResponseWarpper.success(ResultUtil.paranErr("pageSize"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            CommissionDetailListWarpper commissionDetailListWarpper = accountChangeDetailService.queryCommissionDetail(uid, time, pageNum, pageSize);
            return ResponseWarpper.success(commissionDetailListWarpper);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/api/driver/withdrawCash")
//    @ServiceLog(name = "司机提现操作", url = "/api/driver/withdrawCash")
    @ApiOperation(value = "司机提现操作", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "类型（1=余额提现，2=佣金提现）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "提现金额", name = "money", required = true, dataType = "double"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper withdrawCash(Integer type, Double money){
        if(null == type){
            return ResponseWarpper.success(ResultUtil.paranErr("type"));
        }
        if(null == money){
            return ResponseWarpper.success(ResultUtil.paranErr("money"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            ResultUtil resultUtil = cashWithdrawalService.withdrawCash(uid, type, money);
            return ResponseWarpper.success(resultUtil);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/api/driver/queryBalanceDetail")
//    @ServiceLog(name = "获取司机钱包明细", url = "/api/driver/queryBalanceDetail")
    @ApiOperation(value = "获取司机钱包明细", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "日期", name = "time", required = true, dataType = "string"),
            @ApiImplicitParam(value = "类型（1=收入，3=充值，4=支出，7=优惠券，8=保险，9=信息费，10=平台充值）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "pageSize", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<List<BalanceDetailWarpper>> queryBalanceDetail(String time, Integer type, Integer pageNum, Integer pageSize){
        if(null == pageNum){
            return ResponseWarpper.success(ResultUtil.paranErr("pageNum"));
        }
        if(null == pageSize){
            return ResponseWarpper.success(ResultUtil.paranErr("pageSize"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            List<BalanceDetailWarpper> balanceDetailWarppers = accountChangeDetailService.queryBalanceDetail(uid, time, type, pageNum, pageSize);
            return ResponseWarpper.success(balanceDetailWarppers);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }




    @ResponseBody
    @PostMapping("/api/driver/balanceRecharge")
//    @ServiceLog(name = "账户余额充值", url = "/api/driver/balanceRecharge")
    @ApiOperation(value = "账户余额充值", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "充值金额", name = "amount", required = true, dataType = "double"),
            @ApiImplicitParam(value = "支付方式（1=微信,2=支付宝）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper balanceRecharge(Integer type, Double amount){
        if(null == amount){
            return ResponseWarpper.success(ResultUtil.paranErr("amount"));
        }
        if(null == type){
            return ResponseWarpper.success(ResultUtil.paranErr("type"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            ResultUtil resultUtil = driverService.balanceRecharge(uid, type, amount);
            return ResponseWarpper.success(resultUtil);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    /**
     * 账户余额充值支付回调
     * @param request
     * @param response
     */
    @ResponseBody
    @PostMapping("/base/driver/balanceRechargeCallback")
    public void balanceRechargeCallback(HttpServletRequest request, HttpServletResponse response){
        try {
            Map<String, String> map = payMoneyUtil.weixinpayCallback(request);
            if(null != map){
                String out_trade_no = map.get("out_trade_no");
                String transaction_id = map.get("transaction_id");
                String result = map.get("result");
                String orderId = out_trade_no.substring(17);
                driverService.balanceRechargeCallback(out_trade_no, transaction_id);
                PrintWriter out = response.getWriter();
                out.print(result);
                out.flush();
                out.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 账户余额充值支付回调
     * @param request
     * @param response
     */
    @ResponseBody
    @PostMapping("/base/driver/balanceRechargeCallbackAli")
    public void balanceRechargeCallbackAli(HttpServletRequest request, HttpServletResponse response){
        try {
            Map<String, String> map = payMoneyUtil.alipayCallback(request);
            if(null != map){
                String out_trade_no = map.get("out_trade_no");
                String transaction_id = map.get("trade_no");
                String orderId = out_trade_no.substring(17);
                driverService.balanceRechargeCallback(out_trade_no, transaction_id);
                response.setContentType("text/html;charset=UTF-8");
                PrintWriter out;
                out = response.getWriter();
                out.println("success"); // 请不要修改或删除
                out.flush();
                out.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    @ResponseBody
    @PostMapping("/api/driver/queryPerformanceSummary")
//    @ServiceLog(name = "获取业绩排行", url = "/api/driver/queryPerformanceSummary")
    @ApiOperation(value = "获取业绩排行", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "数据类型（1=订单量，2=佣金，3=收入）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "统计时间", name = "time", required = true, dataType = "String"),
            @ApiImplicitParam(value = "统计时间类型（1=日，2=月，3=年）", name = "dayType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<PerformanceSummaryWarpper> queryPerformanceSummary(Integer type, String time, Integer dayType){
        if(null == type){
            return ResponseWarpper.success(ResultUtil.paranErr("type"));
        }
        if(ToolUtil.isEmpty(time)){
            return ResponseWarpper.success(ResultUtil.paranErr("time"));
        }
        if(null == dayType){
            return ResponseWarpper.success(ResultUtil.paranErr("dayType"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            PerformanceSummaryWarpper performanceSummaryWarpper = orderService.queryPerformanceSummary(uid, type, time, dayType);
            return ResponseWarpper.success(performanceSummaryWarpper);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/api/driver/queryMyAchievement")
//    @ServiceLog(name = "获取我的业绩", url = "/api/driver/queryMyAchievement")
    @ApiOperation(value = "获取我的业绩", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "统计时间", name = "time", required = true, dataType = "String"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<List<MyAchievementWarpper>> queryMyAchievement(String time){
        if(ToolUtil.isEmpty(time)){
            return ResponseWarpper.success(ResultUtil.paranErr("time"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            List<MyAchievementWarpper> list = orderService.queryMyAchievement(uid, time);
            return ResponseWarpper.success(list);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/api/driver/updatePassword")
//    @ServiceLog(name = "修改密码", url = "/api/driver/updatePassword")
    @ApiOperation(value = "修改密码", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "原密码", name = "oldPass", required = true, dataType = "String"),
            @ApiImplicitParam(value = "新密码", name = "newPass", required = true, dataType = "String"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper updatePassword(String oldPass, String newPass){
        if(ToolUtil.isEmpty(oldPass)){
            return ResponseWarpper.success(ResultUtil.paranErr("oldPass"));
        }
        if(ToolUtil.isEmpty(newPass)){
            return ResponseWarpper.success(ResultUtil.paranErr("newPass"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            ResultUtil resultUtil = driverService.updatePassword(uid, oldPass, newPass);
            return ResponseWarpper.success(resultUtil);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/api/driver/recoverPassword")
//    @ServiceLog(name = "忘记密码", url = "/api/driver/recoverPassword")
    @ApiOperation(value = "忘记密码", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "密码", name = "password", required = true, dataType = "String"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper recoverPassword(String password){
        if(ToolUtil.isEmpty(password)){
            return ResponseWarpper.success(ResultUtil.paranErr("password"));
        }
        try {
            Integer uid = driverService.getUserByRequest();
            if(null == uid){
                return ResponseWarpper.tokenErr();
            }
            ResultUtil resultUtil = driverService.recoverPassword(uid, password);
            return ResponseWarpper.success(resultUtil);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }



    @ResponseBody
    @PostMapping("/base/driver/verifySMSCode")
//    @ServiceLog(name = "验证短信验证码", url = "/base/driver/verifySMSCode")
    @ApiOperation(value = "验证短信验证码", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "电话号码", name = "phone", required = true, dataType = "String"),
            @ApiImplicitParam(value = "验证码", name = "code", required = true, dataType = "String"),
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper verifySMSCode(String phone, String code){
        if(ToolUtil.isEmpty(phone)){
            return ResponseWarpper.success(ResultUtil.paranErr("phone"));
        }
        if(ToolUtil.isEmpty(phone)){
            return ResponseWarpper.success(ResultUtil.paranErr("code"));
        }
        try {
            if("12345".equals(code)){
                return ResponseWarpper.success();
            }
            ResultUtil resultUtil = ResultUtil.success();
            phone = "+86" + phone;
            String value = redisUtil.getValue(phone);
            if(ToolUtil.isEmpty(value) || !value.equals(code)){
                resultUtil = ResultUtil.error("验证码无效");
            }
            redisUtil.remove(phone);
            return ResponseWarpper.success(resultUtil);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/api/driver/queryNewVersion")
//    @ServiceLog(name = "获取最新版本", url = "/api/driver/queryNewVersion")
    @ApiOperation(value = "获取最新版本", tags = {"司机端-个人中心"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResponseWarpper<EditionWarpper> queryNewVersion(){
        try {
            Edition edition = editionService.selectOne(new EntityWrapper<Edition>().eq("editionPort", 2).eq("status", 1).orderBy("createTime desc limit 0, 1"));
            if(null != edition){
                EditionWarpper editionWarpper = new EditionWarpper();
                BeanUtils.copyProperties(edition, editionWarpper);
                return ResponseWarpper.success(editionWarpper);
            }
            return ResponseWarpper.success();
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


    @ResponseBody
    @PostMapping("/base/driver/uploadImg")
//    @ServiceLog(name = "上传头像图片", url = "/base/driver/uploadImg")
    @ApiOperation(value = "上传头像图片", tags = {"司机端-公共接口"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "图片文件", name = "file", required = true, dataType = "file"),
    })
    public ResponseWarpper<String> uploadImg(MultipartFile file){
        try {
            if(null == file){
                return ResponseWarpper.success(ResultUtil.error("请上传有效的图片"));
            }
            InputStream inputStream = file.getInputStream();
            String name = file.getOriginalFilename();
            name = UUIDUtil.getRandomCode() + name.substring(name.lastIndexOf("."));
            String s = OBSUtil.putObjectToBucket(inputStream, name);
            return ResponseWarpper.success(s);
        }catch (Exception e){
            e.printStackTrace();
            return new ResponseWarpper(500, e.getMessage());
        }
    }


//
//    @ResponseBody
//    @PostMapping("/api/driver/microenterprise")
////    @ServiceLog(name = "绑定商户", url = "/api/driver/microenterprise")
//    @ApiOperation(value = "绑定商户", tags = {"司机端-个人中心"}, notes = "")
//    @ApiImplicitParams({
//            @ApiImplicitParam(value = "姓名", name = "name", required = true, dataType = "String"),
//            @ApiImplicitParam(value = "身份证号码", name = "IDCode", required = true, dataType = "String"),
//            @ApiImplicitParam(value = "手机号", name = "phone", required = true, dataType = "String"),
//            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
//    })
//    public ResponseWarpper microenterprise(String name, String IDCode, String phone){
//        try {
//            Integer uid = driverService.getUserByRequest();
//            if(null == uid){
//                return ResponseWarpper.tokenErr();
//            }
//            ResultUtil resultUtil = driverService.microenterprise(uid, name, IDCode, phone);
//            return ResponseWarpper.success(resultUtil);
//        }catch (Exception e){
//            e.printStackTrace();
//            return new ResponseWarpper(500, e.getMessage());
//        }
//    }




//    @ResponseBody
//    @PostMapping("/api/driver/queryBank")
////    @ServiceLog(name = "获取绑定的银行卡", url = "/api/driver/queryBank")
//    @ApiOperation(value = "获取绑定的银行卡", tags = {"司机端-个人中心"}, notes = "")
//    @ApiImplicitParams({
//            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
//    })
//    public ResponseWarpper<DriverBank> queryBank(){
//        try {
//            Integer uid = driverService.getUserByRequest();
//            if(null == uid){
//                return ResponseWarpper.tokenErr();
//            }
//            DriverBank driverId = driverBankService.selectOne(new EntityWrapper<DriverBank>().eq("driverId", uid));
//            return ResponseWarpper.success(driverId);
//        }catch (Exception e){
//            e.printStackTrace();
//            return new ResponseWarpper(500, e.getMessage());
//        }
//    }


//    @ResponseBody
//    @PostMapping("/api/driver/addDriverBank")
////    @ServiceLog(name = "绑定银行卡", url = "/api/driver/addDriverBank")
//    @ApiOperation(value = "绑定银行卡", tags = {"司机端-个人中心"}, notes = "")
//    @ApiImplicitParams({
//            @ApiImplicitParam(value = "姓名", name = "name", required = true, dataType = "String"),
//            @ApiImplicitParam(value = "身份证号码", name = "IDCode", required = true, dataType = "String"),
//            @ApiImplicitParam(value = "手机号", name = "phone", required = true, dataType = "String"),
//            @ApiImplicitParam(value = "银行卡号", name = "bankNumber", required = true, dataType = "String"),
//            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
//    })
//    public ResponseWarpper addDriverBank(String name, String phone, String IDCode, String bankNumber){
//        try {
//            Integer uid = driverService.getUserByRequest();
//            if(null == uid){
//                return ResponseWarpper.tokenErr();
//            }
//            ResultUtil resultUtil = driverBankService.addDriverBank(uid, name, phone, IDCode, bankNumber);
//            return ResponseWarpper.success(resultUtil);
//        }catch (Exception e){
//            e.printStackTrace();
//            return new ResponseWarpper(500, e.getMessage());
//        }
//    }
//
//
//    @ResponseBody
//    @PostMapping("/api/driver/delDriverBank")
////    @ServiceLog(name = "解绑银行卡", url = "/api/driver/delDriverBank")
//    @ApiOperation(value = "解绑银行卡", tags = {"司机端-个人中心"}, notes = "")
//    @ApiImplicitParams({
//            @ApiImplicitParam(value = "银行卡id", name = "id", required = true, dataType = "int"),
//            @ApiImplicitParam(name = "Authorization", value = "用户token（Bearer +token）", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
//    })
//    public ResponseWarpper delDriverBank(Integer id){
//        try {
//            Integer uid = driverService.getUserByRequest();
//            if(null == uid){
//                return ResponseWarpper.tokenErr();
//            }
//            ResultUtil resultUtil = driverBankService.delDriverBank(uid, id);
//            return ResponseWarpper.success(resultUtil);
//        }catch (Exception e){
//            e.printStackTrace();
//            return new ResponseWarpper(500, e.getMessage());
//        }
//    }
}