package com.stylefeng.guns.modular.system.controller.general;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.stylefeng.guns.core.base.controller.BaseController;
import com.stylefeng.guns.core.common.constant.factory.PageFactory;
import com.stylefeng.guns.core.shiro.ShiroKit;
import com.stylefeng.guns.core.util.DateUtil;
import com.stylefeng.guns.core.util.ExcelUtil;
import com.stylefeng.guns.core.util.ToolUtil;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.ResultUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;


@Controller
@RequestMapping("/spendingDetailPlatform")
public class SpendingDetailPlatformController extends BaseController {

    private String PREFIX = "/system/spendingDetailPlatform/";

    @Autowired
    private ITDriverService driverService;

    @Autowired
    private ITOrderCallService orderCallService;


    @Autowired
    private ITPubWithdrawalService pubWithdrawalService;

    @Autowired
    private IComplaintDeductmoneyService complaintDeductmoneyService;

    @Autowired
    private IDriverActivityHistoryService driverActivityHistoryService;

    @Autowired
    private IDriverActivityService driverActivityService;

    @Autowired
    private IDriverActivityOnlineService driverActivityOnlineService;

    @Autowired
    private IDriverActivityOrderService driverActivityOrderService;

    @Autowired
    private IDriverActivityRegisteredService driverActivityRegisteredService;

    @Autowired
    private IIncomeService incomeService;

    @Autowired
    private ITOrderPrivateCarService privateCarService;

    @Autowired
    private ITOrderTaxiService taxiService;

    @Autowired
    private ITOrderCrossCityService orderCrossCityService;

    @Autowired
    private ITOrderLogisticsService orderLogisticsService;
    
    @Autowired
    private ITSysWithdrawalPoundageService withdrawalPoundageService;
    
    @Autowired
    private ITTimeoutAppealService timeoutAppealService;
    
    @Autowired
    private ITReassignService reassignService;
    
    /**
     * 跳转订单收益明细
     */
    @RequestMapping("/orderRevenueDetails")
    public String index() {
        return PREFIX + "orderRevenueDetails.html";
    }
    
    
    /**
     * 跳转到奖励收益明细
     */
    @RequestMapping("/rewardEarningDetail/{driverId}")
    public String rewardEarningDetail(@PathVariable Integer driverId, Model model) {
        model.addAttribute("driverId",driverId);
        return PREFIX + "rewardEarningDetail.html";
    }


    /**
     * 奖励收益明细列表
     */
    @RequestMapping("/RewardEarningDetailList")
    @ResponseBody
    public Object RewardEarningDetailList(String activityName, Integer driverId) {
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage();
        Wrapper wrapper = new EntityWrapper<DriverActivityHistory>().eq("driverId",driverId).eq("carryOut",2).orderBy("id",false);

        if (ToolUtil.isNotEmpty(activityName)){
            List<DriverActivity> list = driverActivityService.selectList(new EntityWrapper<DriverActivity>().ne("status",1).ne("status",2).like("name",activityName));
            List<Integer> list1 = new ArrayList<>();

            for (DriverActivity driverActivity : list) {
                List<DriverActivityRegistered> list2 = driverActivityRegisteredService.selectList(new EntityWrapper<DriverActivityRegistered>().eq("driverActivityId",driverActivity.getId()));
                list2.forEach(x -> list1.add(x.getId()));

                List<DriverActivityOnline> list3 = driverActivityOnlineService.selectList(new EntityWrapper<DriverActivityOnline>().eq("driverActivityId",driverActivity.getId()));
                list3.forEach(x -> list1.add(x.getId()));

                List<DriverActivityOrder> list4 = driverActivityOrderService.selectList(new EntityWrapper<DriverActivityOrder>().eq("driverActivityId",driverActivity.getId()));
                list4.forEach(x -> list1.add(x.getId()));
            }

            if (list1.size() == 0){
                list1.add(0);
            }

            wrapper.in("activityId",list1);
        }

        List<Map<String,Object>> list = driverActivityHistoryService.selectMapsPage(page,wrapper).getRecords();

        double rewardMoney = 0;
        for (Map<String, Object> map : list) {
            rewardMoney += Double.parseDouble(map.get("money").toString());

            switch (map.get("type").toString()){
                case "1":
                case "2":
                    DriverActivityRegistered driverActivityRegistered = driverActivityRegisteredService.selectById(map.get("activityId").toString());
                    DriverActivity driverActivity = driverActivityService.selectById(driverActivityRegistered.getDriverActivityId());
                    if (ToolUtil.isNotEmpty(driverActivity)){
                        map.put("activityName",driverActivity.getName());
                    }
                    break;
                case "3":
                    DriverActivityOnline driverActivityOnline = driverActivityOnlineService.selectById(map.get("activityId").toString());
                    DriverActivity driverActivity2 = driverActivityService.selectById(driverActivityOnline.getDriverActivityId());
                    if (ToolUtil.isNotEmpty(driverActivity2)){
                        map.put("activityName",driverActivity2.getName());
                    }
                    break;
                case "4":
                    DriverActivityOrder driverActivityOrder = driverActivityOrderService.selectById(map.get("activityId").toString());
                    DriverActivity driverActivity3 = driverActivityService.selectById(driverActivityOrder.getDriverActivityId());
                    if (ToolUtil.isNotEmpty(driverActivity3)){
                        map.put("activityName",driverActivity3.getName());
                    }
                    break;
            }
        }


//        List<DriverActivityHistory> list1 = driverActivityHistoryService.selectList(new EntityWrapper<DriverActivityHistory>().eq("driverId",driverId).eq("carryOut",2));
//        double money = 0;
//        for (DriverActivityHistory driverActivityHistory : list1) {
//            money += driverActivityHistory.getMoney();
//        }

        Map<String,Object> map = new HashMap<>();
        map.put("id","合计收益");
        map.put("money",BigDecimal.valueOf(rewardMoney).setScale(2,BigDecimal.ROUND_HALF_UP));
        list.add(map);

        page.setRecords(list);
        return super.packForBT(page);
    }



    /**
     * 跳转到奖励提现记录
     */
    @RequestMapping("/rewardWithdrawalDetail/{driverId}")
    public String rewardWithdrawalDetail(@PathVariable Integer driverId, Model model) {
        model.addAttribute("driverId",driverId);
        return PREFIX + "rewardWithdrawalDetail.html";
    }



    /**
     * 奖励提现记录列表
     */
    @RequestMapping("/RewardWithdrawalDetailList")
    @ResponseBody
    public Object RewardWithdrawalDetailList(String handleTime, Integer driverId) {
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage();
        Wrapper wrapper = new EntityWrapper<TPubWithdrawal>().eq("type",1).eq("userId",driverId).eq("state",2).eq("userType",2).orderBy("id",false);

        if (ToolUtil.isNotEmpty(handleTime)){
            String[] arr = handleTime.split(" - ");
            wrapper.between("handleTime",arr[0],arr[1]);
        }

        List<Map<String,Object>> list = pubWithdrawalService.selectMapsPage(page,wrapper).getRecords();


        TDriver driver = driverService.selectById(driverId);

        Map<String,Object> map = new HashMap<>();
        map.put("id","已提现合计");
        map.put("money",(driver.getActivityMoney()==null?0:driver.getActivityMoney()) - (driver.getLaveActivityMoney()==null?0:driver.getLaveActivityMoney()));
        list.add(map);

        Map<String,Object> map1 = new HashMap<>();
        map1.put("id","未提现合计");
        map1.put("money",(driver.getLaveActivityMoney()==null?0:driver.getLaveActivityMoney()));
        list.add(map1);

        page.setRecords(list);
        return super.packForBT(page);
    }



    /**
     * 跳转到订单已收明细
     */
    @RequestMapping("/hasCollectOrderDetail/{driverId}")
    public String hasCollectOrderDetail(@PathVariable Integer driverId, Model model) {
        model.addAttribute("driverId",driverId);
        return PREFIX + "hasCollectOrderDetail.html";
    }



    /**
     * 订单已收明细列表
     */
    @RequestMapping("/HasCollectOrderDetailList")
    @ResponseBody
    public Object HasCollectOrderDetailList(String orderNum, String endServiceTime, Integer orderType, Integer driverId) {

        double hasCollect = 0;

        List<Map<String,Object>> listxx = new ArrayList<>();
        if (ToolUtil.isNotEmpty(orderType)){
            if (orderType == 1){

                Wrapper wrapper = new EntityWrapper<TOrderPrivateCar>().eq("driverId",driverId).gt("payMoney",0);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderPrivateCar> list = privateCarService.selectList(wrapper);
                for (TOrderPrivateCar tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "快车");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                    TCompany company = companyService.selectById(tOrderPrivateCar.getCompanyId());

                    ///   司机那一笔订单的净收入
                    List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",2).eq("orderType",1));
                    double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                    List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",6).eq("orderType",1));
                    double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                    map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning));
                    listxx.add(map);

                    hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }else if (orderType == 2){
                Wrapper wrapper = new EntityWrapper<TOrderTaxi>().eq("driverId",driverId).gt("payMoney",0);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderTaxi> list = taxiService.selectList(wrapper);
                for (TOrderTaxi tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "出租车");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                    ///   司机那一笔订单的净收入
                    List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",2).eq("orderType",2));
                    double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                    List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",6).eq("orderType",2));
                    double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                    map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning));

                    listxx.add(map);

                    hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }else if (orderType == 3){
                Wrapper wrapper = new EntityWrapper<TOrderCrossCity>().eq("driverId",driverId).gt("payMoney",0);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderCrossCity> list = orderCrossCityService.selectList(wrapper);
                for (TOrderCrossCity tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "跨城出行");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                    ///   司机那一笔订单的净收入
                    List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",2).eq("orderType",3));
                    double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                    List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",6).eq("orderType",3));
                    double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                    map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning));
                    listxx.add(map);

                    hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }else if (orderType == 4){
                Wrapper wrapper = new EntityWrapper<TOrderLogistics>().eq("type",4).eq("driverId",driverId).gt("payMoney",0);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderLogistics> list = orderLogisticsService.selectList(wrapper);
                for (TOrderLogistics tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "同城小件物流");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                    ///   司机那一笔订单的净收入
                    ///   订单收益
                    List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",2).eq("orderType",4));
                    double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                    ///   感谢费
                    List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",6).eq("orderType",4));
                    double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();

                    ///   超时扣款
                    double timeOutMoney = 0;
                    if (ToolUtil.isNotEmpty(tOrderPrivateCar.getTimeOutMoney())){
                        timeOutMoney += tOrderPrivateCar.getTimeOutMoney().doubleValue();
                    }

                    ///   超时退款
                    double timeOutReturnMoney = 0;
                    TTimeoutAppeal timeoutAppeal = timeoutAppealService.selectOne(new EntityWrapper<TTimeoutAppeal>().eq("state",2).eq("driverId",driverId).eq("orderId",tOrderPrivateCar.getId()));
                    if (ToolUtil.isNotEmpty(timeoutAppeal) && ToolUtil.isNotEmpty(timeoutAppeal.getReturnMoney())){
                        timeOutReturnMoney += timeoutAppeal.getReturnMoney().doubleValue();
                    }
                    map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning + timeOutReturnMoney - timeOutMoney).setScale(2,BigDecimal.ROUND_HALF_UP));

                    listxx.add(map);

                    hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }else if (orderType == 5){
                Wrapper wrapper = new EntityWrapper<TOrderLogistics>().eq("type",5).eq("driverId",driverId).gt("payMoney",0);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderLogistics> list = orderLogisticsService.selectList(wrapper);
                for (TOrderLogistics tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "跨城小件物流");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                    ///   司机那一笔订单的净收入
                    ///   订单收益
                    List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",2).eq("orderType",5));
                    double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                    ///   感谢费
                    List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",6).eq("orderType",5));
                    double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();

                    ///   超时扣款
                    double timeOutMoney = 0;
                    if (ToolUtil.isNotEmpty(tOrderPrivateCar.getTimeOutMoney())){
                        timeOutMoney += tOrderPrivateCar.getTimeOutMoney().doubleValue();
                    }

                    ///   超时退款
                    double timeOutReturnMoney = 0;
                    TTimeoutAppeal timeoutAppeal = timeoutAppealService.selectOne(new EntityWrapper<TTimeoutAppeal>().eq("state",2).eq("driverId",driverId).eq("orderId",tOrderPrivateCar.getId()));
                    if (ToolUtil.isNotEmpty(timeoutAppeal) && ToolUtil.isNotEmpty(timeoutAppeal.getReturnMoney())){
                        timeOutReturnMoney += timeoutAppeal.getReturnMoney().doubleValue();
                    }
                    map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning + timeOutReturnMoney - timeOutMoney).setScale(2,BigDecimal.ROUND_HALF_UP));

                    listxx.add(map);

                    hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }else if (orderType == 6){
                Wrapper wrapper = new EntityWrapper<TOrderCall>().eq("driverId",driverId).gt("payMoney",0);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderCall> list = orderCallService.selectList(wrapper);
                for (TOrderCall tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "95128电召");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                    ///   司机那一笔订单的净收入
                    List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",2).eq("orderType",6));
                    double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                    List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                            .eq("type",6).eq("orderType",6));
                    double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                    map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning));

                    listxx.add(map);

                    hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }
        }else {

            Wrapper wrapper1 = new EntityWrapper<TOrderPrivateCar>().eq("driverId",driverId).gt("payMoney",0);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper1.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper1.between("endServiceTime",arr[0],arr[1]);
            }
            ///   快车（不存在超时扣费和超时退费）
            List<TOrderPrivateCar> list = privateCarService.selectList(wrapper1);
            for (TOrderPrivateCar tOrderPrivateCar : list) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "快车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                ///   司机那一笔订单的净收入
                List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",2).eq("orderType",1));
                double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",6).eq("orderType",1));
                double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning));

                listxx.add(map);

                hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }


            Wrapper wrapper2 = new EntityWrapper<TOrderTaxi>().eq("driverId",driverId).gt("payMoney",0);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper2.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper2.between("endServiceTime",arr[0],arr[1]);
            }

            ///   出租车（不存在超时扣费和超时退费）
            List<TOrderTaxi> list1 = taxiService.selectList(wrapper2);
            for (TOrderTaxi tOrderPrivateCar : list1) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "出租车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                ///   司机那一笔订单的净收入
                List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",2).eq("orderType",2));
                double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                ///   感谢费
                List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",6).eq("orderType",2));
                double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning));

                listxx.add(map);

                hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }


            Wrapper wrapper3 = new EntityWrapper<TOrderCrossCity>().eq("driverId",driverId).gt("payMoney",0);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper3.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper3.between("endServiceTime",arr[0],arr[1]);
            }

            ///   跨城出行（不存在超时扣费和超时退费）
            List<TOrderCrossCity> list2 = orderCrossCityService.selectList(wrapper3);
            for (TOrderCrossCity tOrderPrivateCar : list2) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "跨城出行");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                ///   司机那一笔订单的净收入
                List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",2).eq("orderType",3));
                double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                ///   感谢费
                List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",6).eq("orderType",3));
                double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning).setScale(2,BigDecimal.ROUND_HALF_UP));

                listxx.add(map);

                hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }


            Wrapper wrapper4 = new EntityWrapper<TOrderLogistics>().eq("type",4).eq("driverId",driverId).gt("payMoney",0);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper4.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper4.between("endServiceTime",arr[0],arr[1]);
            }

            ///   同城小件物流
            List<TOrderLogistics> list3 = orderLogisticsService.selectList(wrapper4);
            for (TOrderLogistics tOrderPrivateCar : list3) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "同城小件物流");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                ///   司机那一笔订单的净收入
                ///   订单收益
                List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",2).eq("orderType",4));
                double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                ///   感谢费
                List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",6).eq("orderType",4));
                double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();

                ///   超时扣款
                double timeOutMoney = 0;
                if (ToolUtil.isNotEmpty(tOrderPrivateCar.getTimeOutMoney())){
                    timeOutMoney += tOrderPrivateCar.getTimeOutMoney().doubleValue();
                }

                ///   超时退款
                double timeOutReturnMoney = 0;
                TTimeoutAppeal timeoutAppeal = timeoutAppealService.selectOne(new EntityWrapper<TTimeoutAppeal>().eq("state",2).eq("driverId",driverId).eq("orderId",tOrderPrivateCar.getId()));
                if (ToolUtil.isNotEmpty(timeoutAppeal) && ToolUtil.isNotEmpty(timeoutAppeal.getReturnMoney())){
                    timeOutReturnMoney += timeoutAppeal.getReturnMoney().doubleValue();
                }
                map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning + timeOutReturnMoney - timeOutMoney).setScale(2,BigDecimal.ROUND_HALF_UP));

                listxx.add(map);

                hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }


            Wrapper wrapper5 = new EntityWrapper<TOrderLogistics>().eq("type",5).eq("driverId",driverId).gt("payMoney",0);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper5.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper5.between("endServiceTime",arr[0],arr[1]);
            }

            ///   跨城小件物流
            List<TOrderLogistics> list4 = orderLogisticsService.selectList(wrapper5);
            for (TOrderLogistics tOrderPrivateCar : list4) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", tOrderPrivateCar.getEndServiceTime()==null?"":DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "跨城小件物流");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                ///   司机那一笔订单的净收入
                ///   订单收益
                List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",2).eq("orderType",5));
                double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                ///   感谢费
                List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",6).eq("orderType",5));
                double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();

                ///   超时扣款
                double timeOutMoney = 0;
                if (ToolUtil.isNotEmpty(tOrderPrivateCar.getTimeOutMoney())){
                    timeOutMoney += tOrderPrivateCar.getTimeOutMoney().doubleValue();
                }

                ///   超时退款
                double timeOutReturnMoney = 0;
                TTimeoutAppeal timeoutAppeal = timeoutAppealService.selectOne(new EntityWrapper<TTimeoutAppeal>().eq("state",2).eq("driverId",driverId).eq("orderId",tOrderPrivateCar.getId()));
                if (ToolUtil.isNotEmpty(timeoutAppeal) && ToolUtil.isNotEmpty(timeoutAppeal.getReturnMoney())){
                    timeOutReturnMoney += timeoutAppeal.getReturnMoney().doubleValue();
                }
                map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning + timeOutReturnMoney - timeOutMoney).setScale(2,BigDecimal.ROUND_HALF_UP));

                listxx.add(map);

                hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }


            Wrapper wrapper6 = new EntityWrapper<TOrderCall>().eq("driverId",driverId).gt("payMoney",0);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper6.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper6.between("endServiceTime",arr[0],arr[1]);
            }

            ///   95128电召
            List<TOrderCall> list5 = orderCallService.selectList(wrapper6);
            for (TOrderCall tOrderPrivateCar : list5) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "95128电召");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());

                ///   司机那一笔订单的净收入
                List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",2).eq("orderType",6));
                double orderEarning = incomes.stream().mapToDouble(Income::getMoney).sum();

                List<Income> thankFees = incomeService.selectList(new EntityWrapper<Income>().eq("incomeId",tOrderPrivateCar.getId())
                        .eq("type",6).eq("orderType",6));
                double thankFeeEarning = thankFees.stream().mapToDouble(Income::getMoney).sum();
                map.put("driverOrderEarningMoney", BigDecimal.valueOf(thankFeeEarning + orderEarning));

                listxx.add(map);

                hasCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }
        }


//        double businessIncome;
//        Wrapper wrapper2 = new EntityWrapper<Income>().eq("userType",2).eq("objectId",driverId).eq("type",2);
//
//        List<Income> list2 = incomeService.selectList(wrapper2);
//        businessIncome = list2.stream().mapToDouble(Income::getMoney).sum();

        Map<String,Object> map = new HashMap<>();
        map.put("id","已收合计");
        map.put("orderMoney",BigDecimal.valueOf(hasCollect).setScale(2,BigDecimal.ROUND_HALF_UP));

        double driverEarningTotal = 0;
        for (Map<String, Object> stringObjectMap : listxx) {
            driverEarningTotal += Double.parseDouble(stringObjectMap.get("driverOrderEarningMoney").toString());
        }

        map.put("driverOrderEarningMoney",BigDecimal.valueOf(driverEarningTotal).setScale(2,BigDecimal.ROUND_HALF_UP));
        listxx.add(map);

        return listxx;
    }




    /**
     * 跳转到订单未收明细
     */
    @RequestMapping("/noCollectOrderDetail/{driverId}")
    public String noCollectOrderDetail(@PathVariable Integer driverId, Model model) {
        model.addAttribute("driverId",driverId);
        return PREFIX + "noCollectOrderDetail.html";
    }



    @Autowired
    private ITCompanyService companyService;


    /**
     * 订单未收明细列表
     */
    @RequestMapping("/NoCollectOrderDetailList")
    @ResponseBody
    public Object NoCollectOrderDetailList(String orderNum, String endServiceTime, Integer orderType, Integer driverId) {
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage();


        double noCollect = 0;

        List<Map<String,Object>> listxx = new ArrayList<>();
        if (ToolUtil.isNotEmpty(orderType)){
            if (orderType == 1){

                Wrapper wrapper = new EntityWrapper<TOrderPrivateCar>().eq("state",7).eq("driverId",driverId);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderPrivateCar> list = privateCarService.selectList(wrapper);
                for (TOrderPrivateCar tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "快车");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                    TCompany company = companyService.selectById(tOrderPrivateCar.getCompanyId());
                    if (company.getIsSpeFixedOrProportional() == 1){
                        map.put("driverOrderEarningMoney",
                                BigDecimal.valueOf(tOrderPrivateCar.getOrderMoney().doubleValue() * (1 - company.getSpeMoney().doubleValue()/100) +
                                        (tOrderPrivateCar.getThankYouFee()==null?0:tOrderPrivateCar.getThankYouFee().doubleValue())));
                    }else if (company.getIsSpeFixedOrProportional() == 2){
                        map.put("driverOrderEarningMoney", company.getSpeMoney()
                                .add(tOrderPrivateCar.getThankYouFee()==null?BigDecimal.ZERO:tOrderPrivateCar.getThankYouFee()).setScale(2,BigDecimal.ROUND_HALF_UP));
                    }
                    listxx.add(map);

                    noCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }else if (orderType == 2){
                Wrapper wrapper = new EntityWrapper<TOrderTaxi>().eq("state",7).eq("driverId",driverId);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderTaxi> list = taxiService.selectList(wrapper);
                for (TOrderTaxi tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "出租车");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                    TCompany company = companyService.selectById(tOrderPrivateCar.getCompanyId());
                    if (company.getIsTaxiFixedOrProportional() == 1){
                        map.put("driverOrderEarningMoney",
                                BigDecimal.valueOf(tOrderPrivateCar.getOrderMoney().doubleValue() * (1 - company.getTaxiMoney().doubleValue()/100) +
                                        (tOrderPrivateCar.getThankYouFee()==null?0:tOrderPrivateCar.getThankYouFee().doubleValue())));
                    }else if (company.getIsTaxiFixedOrProportional() == 2){
                        map.put("driverOrderEarningMoney", company.getTaxiMoney()
                                .add(tOrderPrivateCar.getThankYouFee()==null?BigDecimal.ZERO:tOrderPrivateCar.getThankYouFee()).setScale(2,BigDecimal.ROUND_HALF_UP));
                    }
                    listxx.add(map);

                    noCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }else if (orderType == 3){
                Wrapper wrapper = new EntityWrapper<TOrderCall>().eq("state",7).eq("driverId",driverId);

                if (ToolUtil.isNotEmpty(orderNum)){
                    wrapper.like("orderNum",orderNum);
                }

                if (ToolUtil.isNotEmpty(endServiceTime)){
                    String[] arr = endServiceTime.split(" - ");
                    wrapper.between("endServiceTime",arr[0],arr[1]);
                }

                List<TOrderCall> list = orderCallService.selectList(wrapper);
                for (TOrderCall tOrderPrivateCar : list) {
                    Map<String,Object> map = new HashMap<>();
                    map.put("id", tOrderPrivateCar.getId());
                    map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                    map.put("orderType", "95128电召");
                    map.put("orderNum", tOrderPrivateCar.getOrderNum());
                    map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                    TCompany company = companyService.selectById(tOrderPrivateCar.getCompanyId());
                    if (company.getIsOnCallFixedOrProportional() == 1){
                        map.put("driverOrderEarningMoney",
                                BigDecimal.valueOf(tOrderPrivateCar.getOrderMoney().doubleValue() * (1 - company.getOnCallMoney().doubleValue()/100) +
                                        (tOrderPrivateCar.getThankYouFee()==null?0:tOrderPrivateCar.getThankYouFee().doubleValue())));
                    }else if (company.getIsOnCallFixedOrProportional() == 2){
                        map.put("driverOrderEarningMoney", company.getOnCallMoney()
                                .add(tOrderPrivateCar.getThankYouFee()==null?BigDecimal.ZERO:tOrderPrivateCar.getThankYouFee()).setScale(2,BigDecimal.ROUND_HALF_UP));
                    }
                    listxx.add(map);

                    noCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
                }
            }
        }else {

            Wrapper wrapper1 = new EntityWrapper<TOrderPrivateCar>().eq("state",7).eq("driverId",driverId);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper1.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper1.between("endServiceTime",arr[0],arr[1]);
            }
            ///   快车
            List<TOrderPrivateCar> list = privateCarService.selectList(wrapper1);
            for (TOrderPrivateCar tOrderPrivateCar : list) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "快车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TCompany company = companyService.selectById(tOrderPrivateCar.getCompanyId());
                if (company.getIsSpeFixedOrProportional() == 1){
                    map.put("driverOrderEarningMoney",
                            BigDecimal.valueOf(tOrderPrivateCar.getOrderMoney().doubleValue() * (1 - company.getSpeMoney().doubleValue()/100) +
                                    (tOrderPrivateCar.getThankYouFee()==null?0:tOrderPrivateCar.getThankYouFee().doubleValue())));
                }else if (company.getIsSpeFixedOrProportional() == 2){
                    map.put("driverOrderEarningMoney", company.getSpeMoney()
                            .add(tOrderPrivateCar.getThankYouFee()==null?BigDecimal.ZERO:tOrderPrivateCar.getThankYouFee()).setScale(2,BigDecimal.ROUND_HALF_UP));
                }
                listxx.add(map);

                noCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }


            Wrapper wrapper2 = new EntityWrapper<TOrderTaxi>().eq("state",7).eq("driverId",driverId);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper2.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper2.between("endServiceTime",arr[0],arr[1]);
            }

            ///   出租车
            List<TOrderTaxi> list1 = taxiService.selectList(wrapper2);
            for (TOrderTaxi tOrderPrivateCar : list1) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "出租车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TCompany company = companyService.selectById(tOrderPrivateCar.getCompanyId());
                if (company.getIsTaxiFixedOrProportional() == 1){
                    map.put("driverOrderEarningMoney",
                            BigDecimal.valueOf(tOrderPrivateCar.getOrderMoney().doubleValue() * (1 - company.getTaxiMoney().doubleValue()/100) +
                                    (tOrderPrivateCar.getThankYouFee()==null?0:tOrderPrivateCar.getThankYouFee().doubleValue())));
                }else if (company.getIsTaxiFixedOrProportional() == 2){
                    map.put("driverOrderEarningMoney", company.getTaxiMoney()
                            .add(tOrderPrivateCar.getThankYouFee()==null?BigDecimal.ZERO:tOrderPrivateCar.getThankYouFee()).setScale(2,BigDecimal.ROUND_HALF_UP));
                }
                listxx.add(map);

                noCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }


            Wrapper wrapper6 = new EntityWrapper<TOrderCall>().eq("state",7).eq("driverId",driverId);

            if (ToolUtil.isNotEmpty(orderNum)){
                wrapper6.like("orderNum",orderNum);
            }

            if (ToolUtil.isNotEmpty(endServiceTime)){
                String[] arr = endServiceTime.split(" - ");
                wrapper6.between("endServiceTime",arr[0],arr[1]);
            }

            ///   95128电召
            List<TOrderCall> list5 = orderCallService.selectList(wrapper6);
            for (TOrderCall tOrderPrivateCar : list5) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "95128电召");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TCompany company = companyService.selectById(tOrderPrivateCar.getCompanyId());
                if (company.getIsOnCallFixedOrProportional() == 1){
                    map.put("driverOrderEarningMoney",
                            BigDecimal.valueOf(tOrderPrivateCar.getOrderMoney().doubleValue() * (1 - company.getOnCallMoney().doubleValue()/100) +
                                    (tOrderPrivateCar.getThankYouFee()==null?0:tOrderPrivateCar.getThankYouFee().doubleValue())));
                }else if (company.getIsOnCallFixedOrProportional() == 2){
                    map.put("driverOrderEarningMoney", company.getOnCallMoney()
                            .add(tOrderPrivateCar.getThankYouFee()==null?BigDecimal.ZERO:tOrderPrivateCar.getThankYouFee()).setScale(2,BigDecimal.ROUND_HALF_UP));
                }
                listxx.add(map);

                noCollect += tOrderPrivateCar.getOrderMoney().doubleValue();
            }
        }


        Map<String,Object> map = new HashMap<>();
        map.put("id","未收合计");
        map.put("orderMoney",noCollect);
        listxx.add(map);

        page.setRecords(listxx);
        return super.packForBT(page);
    }



    /**
     * 跳转到订单提现明细
     */
    @RequestMapping("/orderWithdrawalDetail/{driverId}")
    public String orderWithdrawalDetail(@PathVariable Integer driverId, Model model) {
        model.addAttribute("driverId",driverId);
        return PREFIX + "orderWithdrawalDetail.html";
    }



    /**
     * 订单提现明细列表
     */
    @RequestMapping("/OrderWithdrawalDetailList")
    @ResponseBody
    public Object OrderWithdrawalDetailList(String handleTime, Integer driverId) {
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage();
        Wrapper wrapper = new EntityWrapper<TPubWithdrawal>().eq("type",2).eq("userId",driverId).eq("state",2).eq("userType",2).orderBy("id",false);

        if (ToolUtil.isNotEmpty(handleTime)){
            String[] arr = handleTime.split(" - ");
            wrapper.between("handleTime",arr[0],arr[1]);
        }

        List<Map<String,Object>> list = pubWithdrawalService.selectMapsPage(page,wrapper).getRecords();
        double hasWithDrawalMoney = 0;
        for (Map<String, Object> map : list) {
            hasWithDrawalMoney += Double.parseDouble(map.get("money").toString());
        }


        TDriver driver = driverService.selectById(driverId);

        Map<String,Object> map = new HashMap<>();
        map.put("id","已提现合计");
        map.put("money",new BigDecimal(hasWithDrawalMoney).setScale(2, BigDecimal.ROUND_HALF_UP));
        list.add(map);


        ////   投诉扣款涉及金额
//        double businessIncomes = 0;
//        Wrapper wrapper3 = new EntityWrapper<ComplaintDeductmoney>().eq("driverId",map.get("id"));
//
//        if (ToolUtil.isNotEmpty(handleTime)){
//            String[] arr = handleTime.split(" - ");
//            wrapper3.between("createTime",arr[0],arr[1]);
//        }
//        List<ComplaintDeductmoney> list3 = complaintDeductmoneyService.selectList(wrapper3);
//        for (ComplaintDeductmoney complaintDeductmoney : list3) {
//            businessIncomes += complaintDeductmoney.getMoney().doubleValue();
//        }

        Map<String,Object> map1 = new HashMap<>();
        map1.put("id","未提现合计");
        map1.put("money", BigDecimal.valueOf(driver.getLaveBusinessMoney() == null ? 0 : driver.getLaveBusinessMoney()).setScale(2,BigDecimal.ROUND_HALF_UP));
        list.add(map1);

        page.setRecords(list);
        return super.packForBT(page);
    }



    /**
     * 查看详情
     */
    @RequestMapping(value = "/detail/{driverId}")
    public String detail(@PathVariable Integer driverId, Model model){
        Map<String, Object> map = driverService.selectMap(new EntityWrapper<TDriver>().eq("id", driverId).eq("companyId", ShiroKit.getUser().getObjectId()));

        double activityIncome;
        Wrapper wrapper1 = new EntityWrapper<Income>().eq("userType",2).eq("objectId",driverId).eq("type",1);

        List<Income> list1 = incomeService.selectList(wrapper1);
        activityIncome = list1.stream().mapToDouble(Income::getMoney).sum();

        double businessIncome;
        Wrapper wrapper2 = new EntityWrapper<Income>().eq("userType",2).eq("objectId",driverId).eq("type",2);

        List<Income> list2 = incomeService.selectList(wrapper2);
        businessIncome = list2.stream().mapToDouble(Income::getMoney).sum();


        ////   投诉扣款涉及金额
//        double businessIncomes = 0;
//        Wrapper wrapper3 = new EntityWrapper<ComplaintDeductmoney>().eq("driverId",map.get("id"));
//        List<ComplaintDeductmoney> list3 = complaintDeductmoneyService.selectList(wrapper3);
//        for (ComplaintDeductmoney complaintDeductmoney : list3) {
//            businessIncomes += complaintDeductmoney.getMoney().doubleValue();
//        }


        ///   收益总计
        map.put("allEarning", BigDecimal.valueOf(Double.parseDouble(map.get("activityMoney").toString()) + Double.parseDouble(map.get("businessMoney").toString()))
                .setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());

        ///   奖励收益总计
        map.put("allReward", new BigDecimal(activityIncome).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());

        ///   订单收益总计
        map.put("allOrderEarning", new BigDecimal(businessIncome).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());



        ///   奖励已提现统计
        double hasWithdrawalReward = 0;

        Wrapper wrapper10 = new EntityWrapper<TPubWithdrawal>().eq("state",2)
                .eq("type",1).eq("userType",2).eq("userId",driverId);

        List<TPubWithdrawal> list10 = pubWithdrawalService.selectList(wrapper10);

        for (TPubWithdrawal tPubWithdrawal : list10) {
            hasWithdrawalReward += tPubWithdrawal.getMoney().doubleValue();
        }

        map.put("hasWithdrawalReward", new BigDecimal(hasWithdrawalReward).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());


        /*
         * 奖励未提现总计
         */
        map.put("noWithdrawalReward", BigDecimal.valueOf(Double.parseDouble(map.get("laveActivityMoney").toString())).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());




        double needCollectOrder = orderCallService.orderNoCollect(driverId,null,null);


        /*
         * 订单未收总计
         */
        map.put("needCollectOrder",new BigDecimal(needCollectOrder).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());



        ///   订单已提现统计
        double hasWithdrawalOrder = 0;

        Wrapper wrapper8 = new EntityWrapper<TPubWithdrawal>().eq("state",2)
                .eq("type",2).eq("userType",2).eq("userId",driverId);

        List<TPubWithdrawal> list8 = pubWithdrawalService.selectList(wrapper8);

        for (TPubWithdrawal tPubWithdrawal : list8) {
            hasWithdrawalOrder += tPubWithdrawal.getMoney().doubleValue();
        }

        map.put("hasWithdrawalOrder", new BigDecimal(hasWithdrawalOrder).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());


        /*
         * 订单未提现总计  (剩余业务金额是扣除一系列杂费（包括提现）之后的金额)
         */
        map.put("noWithdrawalOrder", BigDecimal.valueOf(Double.parseDouble(map.get("laveBusinessMoney").toString())).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());


        model.addAttribute("item",map);

        return PREFIX + "detail.html";
    }



    /**
     * 获取列表
     */
    @RequestMapping(value = "/list")
    @ResponseBody
    public Object list(String driverName, String driverPhone, String startTime, String endTime) {
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage();
        Wrapper wrapper = new EntityWrapper<TDriver>().eq("companyId", ShiroKit.getUser().getObjectId()).orderBy("id", false);
    
        if (ToolUtil.isNotEmpty(driverName)) {
            wrapper.like("name", driverName);
        }
        if (ToolUtil.isNotEmpty(driverPhone)) {
            wrapper.like("phone", driverPhone);
        }
    
        List<Map<String, Object>> list = driverService.selectMapsPage(page, wrapper).getRecords();
    
        for (Map<String, Object> map : list) {

            ///  活动收益
            double activityIncome;
            Wrapper wrapper1 = new EntityWrapper<Income>().eq("userType",2).eq("objectId",map.get("id")).eq("type",1);
            if (ToolUtil.isNotEmpty(startTime) && ToolUtil.isNotEmpty(endTime)){
                wrapper1.between("insertTime",startTime,endTime);
            }
            List<Income> list1 = incomeService.selectList(wrapper1);
            activityIncome = list1.stream().mapToDouble(Income::getMoney).sum();


            ///  订单收益(收入明细表的数据已经是扣除了杂费之后的净值金额)
            double businessIncome;
            Wrapper wrapper2 = new EntityWrapper<Income>().eq("userType",2).eq("objectId",map.get("id")).eq("type",2);
            if (ToolUtil.isNotEmpty(startTime) && ToolUtil.isNotEmpty(endTime)){
                wrapper2.between("insertTime",startTime,endTime);
            }
            List<Income> list2 = incomeService.selectList(wrapper2);
            businessIncome = list2.stream().mapToDouble(Income::getMoney).sum();


            ///  感谢费收益
            double thankFeeIncome;
            Wrapper wrapper4 = new EntityWrapper<Income>().eq("userType",2).eq("objectId",map.get("id")).eq("type",6);
            if (ToolUtil.isNotEmpty(startTime) && ToolUtil.isNotEmpty(endTime)){
                wrapper2.between("insertTime",startTime,endTime);
            }
            List<Income> list4 = incomeService.selectList(wrapper4);
            thankFeeIncome = list4.stream().mapToDouble(Income::getMoney).sum();



            ////   投诉扣款涉及金额
            double businessIncomes = 0;
            Wrapper wrapper3 = new EntityWrapper<ComplaintDeductmoney>().eq("driverId",map.get("id"));
            if (ToolUtil.isNotEmpty(startTime) && ToolUtil.isNotEmpty(endTime)){
                wrapper3.between("createTime",startTime,endTime);
            }
            List<ComplaintDeductmoney> list3 = complaintDeductmoneyService.selectList(wrapper3);
            for (ComplaintDeductmoney complaintDeductmoney : list3) {
                businessIncomes += complaintDeductmoney.getMoney().doubleValue();
            }


            ///   订单改派
            double reassignMoney = 0;
            Wrapper wrapper5 = new EntityWrapper<TReassign>().eq("state",2).eq("payType",3).eq("originalDriverId",map.get("id"));
            if (ToolUtil.isNotEmpty(startTime) && ToolUtil.isNotEmpty(endTime)){
                wrapper5.between("insertTime",startTime,endTime);
            }
            List<TReassign> list5 = reassignService.selectList(wrapper5);
            for (TReassign tReassign : list5) {
                reassignMoney += tReassign.getMoney();
            }


            ///   收益总计
            map.put("allEarning", new BigDecimal(activityIncome + businessIncome + thankFeeIncome).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());

            ///   奖励收益总计
            map.put("allReward", new BigDecimal(activityIncome).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());


            ///   订单收益总计
            map.put("allOrderEarning", new BigDecimal(businessIncome).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());



            ///   奖励已提现统计
            double hasWithdrawalReward = 0;

            Wrapper wrapper10 = new EntityWrapper<TPubWithdrawal>().eq("state",2)
                    .eq("type",1).eq("userType",2).eq("userId",map.get("id"));

            if (ToolUtil.isNotEmpty(startTime) && ToolUtil.isNotEmpty(endTime)){
                wrapper10.between("handleTime",startTime,endTime);
            }

            List<TPubWithdrawal> list10 = pubWithdrawalService.selectList(wrapper10);

            for (TPubWithdrawal tPubWithdrawal : list10) {
                hasWithdrawalReward += tPubWithdrawal.getMoney().doubleValue();
            }

            map.put("hasWithdrawalReward", new BigDecimal(hasWithdrawalReward).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());


            /*
             * 奖励未提现总计
             */
            if ((activityIncome - hasWithdrawalReward) > Double.parseDouble(map.get("laveActivityMoney")==null?"0":map.get("laveActivityMoney").toString())){
                ///   计算未提现奖励  大于  数据库司机的剩余活动奖励时，说明有订单改派消耗
                map.put("noWithdrawalReward", new BigDecimal(activityIncome - hasWithdrawalReward - reassignMoney).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());
            }else {
                map.put("noWithdrawalReward", new BigDecimal(activityIncome - hasWithdrawalReward).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());
            }



            double needCollectOrder = orderCallService.orderNoCollect(Integer.parseInt(map.get("id").toString()),startTime,endTime);


            /*
             * 订单未收总计
             */
            map.put("needCollectOrder",new BigDecimal(needCollectOrder).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());



            ///   订单已提现统计
            double hasWithdrawalOrder = 0;

            Wrapper wrapper8 = new EntityWrapper<TPubWithdrawal>().eq("state",2)
                    .eq("type",2).eq("userType",2).eq("userId",map.get("id"));

            if (ToolUtil.isNotEmpty(startTime) && ToolUtil.isNotEmpty(endTime)){
                wrapper8.between("handleTime",startTime,endTime);
            }

            List<TPubWithdrawal> list8 = pubWithdrawalService.selectList(wrapper8);

            for (TPubWithdrawal tPubWithdrawal : list8) {
                hasWithdrawalOrder += tPubWithdrawal.getMoney().doubleValue();
            }

            map.put("hasWithdrawalOrder", new BigDecimal(hasWithdrawalOrder).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());



            /*
             * 订单未提现总计
             */
            if ((businessIncome + thankFeeIncome - businessIncomes - hasWithdrawalOrder) > Double.parseDouble(map.get("laveBusinessMoney")==null?"0":map.get("laveBusinessMoney").toString())){
                ///   计算未提现订单  大于  数据库司机的剩余订单奖励时，说明有订单改派消耗
                map.put("noWithdrawalOrder", new BigDecimal(businessIncome + thankFeeIncome - businessIncomes - hasWithdrawalOrder - reassignMoney).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());
            }else {
                map.put("noWithdrawalOrder", new BigDecimal(businessIncome + thankFeeIncome - businessIncomes - hasWithdrawalOrder).setScale(2,BigDecimal.ROUND_HALF_UP).doubleValue());
            }
        }

        page.setRecords(list);
        return super.packForBT(page);
    }


    /**
     * 平台支出明细首页导出
     */
    @RequestMapping(value = "/exportRecord")
    @ResponseBody
    public Object exportRecord(HttpServletResponse response, @RequestParam String driverName,
                               @RequestParam String driverPhone, @RequestParam String startTime, @RequestParam String endTime, @RequestParam String ids) {
        try {

            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyyMMdd");
            String time = format.format(date);
            String fileName = "平台支出明细"+time+".xls";
            String[] title = new String[] {"司机名称","司机手机号","收益总金额","奖励收益总计","奖励已结算金额","奖励未结算金额","订单已收总计","订单未收总计","订单已提现总计","订单未提现总计"};
            List<Map<String,Object>> mapList = getDriverList(driverName, driverPhone, startTime, endTime, ids);

            System.out.println(mapList);

            String[][] values = new String[mapList.size()][];
            for (int i = 0; i < mapList.size(); i++) {
                Map<String,Object> d=mapList.get(i);
                values[i] = new String[title.length];
                if (ToolUtil.isNotEmpty(d.get("driverName").toString())){
                    values[i][0]=d.get("driverName").toString();
                }else {
                    values[i][0]="";
                }
                if (ToolUtil.isNotEmpty(d.get("driverPhone").toString())){
                    values[i][1]=d.get("driverPhone").toString();
                }else {
                    values[i][1]="";
                }
                values[i][2]=d.get("allEarning").toString();
                values[i][3]=d.get("allReward").toString();
                values[i][4]=d.get("hasWithdrawalReward").toString();
                values[i][5] = d.get("noWithdrawalReward").toString();
                values[i][6] = d.get("allOrderEarning").toString();
                values[i][7] = d.get("needCollectOrder").toString();
                values[i][8] = d.get("hasWithdrawalOrder").toString();
                values[i][9] = d.get("noWithdrawalOrder").toString();
            }
            String fileNameTitle="平台支出明细";
            HSSFWorkbook wb = ExcelUtil.getHSSFWorkbook(fileNameTitle+time, title, values, null);
            ExcelUtil.setResponseHeader(response, fileName);
            OutputStream os = response.getOutputStream();
            wb.write(os);
            os.flush();
            os.close();

        } catch (Exception e) {
            e.printStackTrace();
            /*return ApiUtil.putFailObj("导出失败");*/
        }
        return SUCCESS_TIP;
    }



    private List<Map<String,Object>> getDriverList(String driverName, String driverPhone, String startTime, String endTime, String ids){

        Wrapper wrapper = new EntityWrapper<TDriver>().orderBy("id", false);

        if (ToolUtil.isNotEmpty(driverName)) {
            wrapper.like("name", driverName);
        }
        if (ToolUtil.isNotEmpty(driverPhone)) {
            wrapper.like("phone", driverPhone);
        }

        List<String> idList = new ArrayList<>();
        if (!ids.equals("All")){
            String[] arr = ids.split(",");
            for (String s : arr) {
                idList.add(s);
            }

            if (idList.size() == 0){
                idList.add("0");
            }

            wrapper.in("id",idList);
        }

        return orderCallService.excel(startTime,endTime,idList);
    }



    /**
     * 奖励收益明细首页导出
     */
    @RequestMapping(value = "/exportRecordx")
    @ResponseBody
    public Object exportRecordx(HttpServletResponse response,@RequestParam String ids,@RequestParam Integer driverId) {
        try {

            Wrapper wrapper = new EntityWrapper<DriverActivityHistory>().eq("driverId",driverId).eq("carryOut",2).orderBy("id",false);

            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyyMMdd");
            String time = format.format(date);
            String fileName = "奖励收益明细"+time+".xls";
            String[] title = new String[] {"序号","收益活动名称","收益金额"};

            List<String> idsList = new ArrayList<>();
            if (!ids.equals("All")){
                String[] arr = ids.split(",");
                for (String s : arr) {
                    idsList.add(s);
                }

                wrapper.in("id",idsList);
            }

            List<Map<String,Object>> mapList = driverActivityHistoryService.selectMaps(wrapper);

            for (Map<String, Object> map : mapList) {
                switch (map.get("type").toString()){
                    case "1":
                    case "2":
                        DriverActivityRegistered driverActivityRegistered = driverActivityRegisteredService.selectById(map.get("activityId").toString());
                        DriverActivity driverActivity = driverActivityService.selectById(driverActivityRegistered.getDriverActivityId());
                        if (ToolUtil.isNotEmpty(driverActivity)){
                            map.put("activityName",driverActivity.getName());
                        }
                        break;
                    case "3":
                        DriverActivityOnline driverActivityOnline = driverActivityOnlineService.selectById(map.get("activityId").toString());
                        DriverActivity driverActivity2 = driverActivityService.selectById(driverActivityOnline.getDriverActivityId());
                        if (ToolUtil.isNotEmpty(driverActivity2)){
                            map.put("activityName",driverActivity2.getName());
                        }
                        break;
                    case "4":
                        DriverActivityOrder driverActivityOrder = driverActivityOrderService.selectById(map.get("activityId").toString());
                        DriverActivity driverActivity3 = driverActivityService.selectById(driverActivityOrder.getDriverActivityId());
                        if (ToolUtil.isNotEmpty(driverActivity3)){
                            map.put("activityName",driverActivity3.getName());
                        }
                        break;
                }
            }

            System.out.println(mapList);

            String[][] values = new String[mapList.size()][];
            for (int i = 0; i < mapList.size(); i++) {
                Map<String,Object> d=mapList.get(i);
                values[i] = new String[title.length];
                values[i][0]=d.get("id").toString();

                if (ToolUtil.isNotEmpty(d.get("activityName").toString())){
                    values[i][1]=d.get("activityName").toString();
                }else {
                    values[i][1]="";
                }

                if (ToolUtil.isNotEmpty(d.get("money").toString())){
                    values[i][2]=d.get("money").toString();
                }else {
                    values[i][2] = "0";
                }
            }
            String fileNameTitle="奖励收益明细";
            HSSFWorkbook wb = ExcelUtil.getHSSFWorkbook(fileNameTitle+time, title, values, null);
            ExcelUtil.setResponseHeader(response, fileName);
            OutputStream os = response.getOutputStream();
            wb.write(os);
            os.flush();
            os.close();

        } catch (Exception e) {
            e.printStackTrace();
            /*return ApiUtil.putFailObj("导出失败");*/
        }
        return SUCCESS_TIP;
    }



    /**
     * 奖励提现明细首页导出
     */
    @RequestMapping(value = "/exportRecordxx")
    @ResponseBody
    public Object exportRecordxx(HttpServletResponse response,@RequestParam String ids,@RequestParam Integer driverId) {
        try {

            Wrapper wrapper = new EntityWrapper<TPubWithdrawal>().eq("type",1).eq("userId",driverId).eq("state",2).eq("userType",2).orderBy("id",false);

            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyyMMdd");
            String time = format.format(date);
            String fileName = "奖励提现记录"+time+".xls";
            String[] title = new String[] {"序号","时间","提现金额"};

            List<String> idsList = new ArrayList<>();
            if (!ids.equals("All")){
                String[] arr = ids.split(",");
                for (String s : arr) {
                    idsList.add(s);
                }

                wrapper.in("id",idsList);
            }

            List<Map<String,Object>> mapList = pubWithdrawalService.selectMaps(wrapper);

            System.out.println(mapList);

            String[][] values = new String[mapList.size()][];
            for (int i = 0; i < mapList.size(); i++) {
                Map<String,Object> d=mapList.get(i);
                values[i] = new String[title.length];
                values[i][0]=d.get("id").toString();

                if (ToolUtil.isNotEmpty(d.get("handleTime").toString())){
                    values[i][1]=d.get("handleTime").toString();
                }else {
                    values[i][1]="";
                }

                if (ToolUtil.isNotEmpty(d.get("money").toString())){
                    values[i][2]=d.get("money").toString();
                }else {
                    values[i][2] = "0";
                }
            }
            String fileNameTitle="奖励提现记录";
            HSSFWorkbook wb = ExcelUtil.getHSSFWorkbook(fileNameTitle+time, title, values, null);
            ExcelUtil.setResponseHeader(response, fileName);
            OutputStream os = response.getOutputStream();
            wb.write(os);
            os.flush();
            os.close();

        } catch (Exception e) {
            e.printStackTrace();
            /*return ApiUtil.putFailObj("导出失败");*/
        }
        return SUCCESS_TIP;
    }




    /**
     * 订单已收明细导出
     */
    @RequestMapping(value = "/exportRecordxxx")
    @ResponseBody
    public Object exportRecordxxx(HttpServletResponse response,@RequestParam String ids,@RequestParam Integer driverId) {
        try {

            Wrapper wrapper = new EntityWrapper<TPubWithdrawal>().eq("type",1).eq("userId",driverId).eq("state",2).eq("userType",2).orderBy("id",false);

            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyyMMdd");
            String time = format.format(date);
            String fileName = "订单已收明细"+time+".xls";
            String[] title = new String[] {"序号","时间","订单类型","订单ID","订单类型","订单金额","收益金额"};

            List<String> idsList = new ArrayList<>();
            if (!ids.equals("All")){
                String[] arr = ids.split(",");
                for (String s : arr) {
                    idsList.add(s);
                }

                wrapper.in("id",idsList);
            }

            List<Map<String,Object>> mapList = new ArrayList<>();


            Wrapper wrapper1 = new EntityWrapper<TOrderPrivateCar>().eq("driverId",driverId).gt("payMoney",0);

            ///   快车
            List<TOrderPrivateCar> list = privateCarService.selectList(wrapper1);
            for (TOrderPrivateCar tOrderPrivateCar : list) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "快车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }


            Wrapper wrapper2 = new EntityWrapper<TOrderTaxi>().eq("driverId",driverId).gt("payMoney",0);

            ///   出租车
            List<TOrderTaxi> list1 = taxiService.selectList(wrapper2);
            for (TOrderTaxi tOrderPrivateCar : list1) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "出租车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }


            Wrapper wrapper3 = new EntityWrapper<TOrderCrossCity>().eq("driverId",driverId).gt("payMoney",0);

            ///   跨城出行
            List<TOrderCrossCity> list2 = orderCrossCityService.selectList(wrapper3);
            for (TOrderCrossCity tOrderPrivateCar : list2) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "跨城出行");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }


            Wrapper wrapper4 = new EntityWrapper<TOrderLogistics>().eq("type",4).eq("driverId",driverId).gt("payMoney",0);

            ///   同城小件物流
            List<TOrderLogistics> list3 = orderLogisticsService.selectList(wrapper4);
            for (TOrderLogistics tOrderPrivateCar : list3) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "同城小件物流");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }


            Wrapper wrapper5 = new EntityWrapper<TOrderLogistics>().eq("type",5).eq("driverId",driverId).gt("payMoney",0);

            ///   跨城小件物流
            List<TOrderLogistics> list4 = orderLogisticsService.selectList(wrapper5);
            for (TOrderLogistics tOrderPrivateCar : list4) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "跨城小件物流");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }


            Wrapper wrapper6 = new EntityWrapper<TOrderCall>().eq("driverId",driverId).gt("payMoney",0);

            ///   95128电召
            List<TOrderCall> list5 = orderCallService.selectList(wrapper6);
            for (TOrderCall tOrderPrivateCar : list5) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "95128电召");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }

            System.out.println(mapList);

            String[][] values = new String[mapList.size()][];
            for (int i = 0; i < mapList.size(); i++) {
                Map<String,Object> d=mapList.get(i);
                values[i] = new String[title.length];
                values[i][0]=d.get("id").toString();

                if (ToolUtil.isNotEmpty(d.get("endServiceTime"))){
                    values[i][1]=d.get("endServiceTime").toString();
                }else {
                    values[i][1]="";
                }

                if (ToolUtil.isNotEmpty(d.get("orderType"))){
                    values[i][2]=d.get("orderType").toString();
                }else {
                    values[i][2] = "";
                }

                if (ToolUtil.isNotEmpty(d.get("orderNum"))){
                    values[i][3]=d.get("orderNum").toString();
                }else {
                    values[i][3] = "";
                }

                if (ToolUtil.isNotEmpty(d.get("orderMoney"))){
                    values[i][4]=d.get("orderMoney").toString();
                }else {
                    values[i][4] = "";
                }

                if (ToolUtil.isNotEmpty(d.get("driverOrderEarningMoney"))){
                    values[i][5]=d.get("driverOrderEarningMoney").toString();
                }else {
                    values[i][5] = "";
                }
            }
            String fileNameTitle="订单已收明细";
            HSSFWorkbook wb = ExcelUtil.getHSSFWorkbook(fileNameTitle+time, title, values, null);
            ExcelUtil.setResponseHeader(response, fileName);
            OutputStream os = response.getOutputStream();
            wb.write(os);
            os.flush();
            os.close();

        } catch (Exception e) {
            e.printStackTrace();
            /*return ApiUtil.putFailObj("导出失败");*/
        }
        return SUCCESS_TIP;
    }



    /**
     * 订单未收明细导出
     */
    @RequestMapping(value = "/exportRecordxxxx")
    @ResponseBody
    public Object exportRecordxxxx(HttpServletResponse response,@RequestParam String ids,@RequestParam Integer driverId) {
        try {

            Wrapper wrapper = new EntityWrapper<TPubWithdrawal>().eq("type",1).eq("userId",driverId).eq("state",2).eq("userType",2).orderBy("id",false);

            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyyMMdd");
            String time = format.format(date);
            String fileName = "订单未收明细"+time+".xls";
            String[] title = new String[] {"序号","时间","订单类型","订单ID","订单类型","订单金额","收益金额"};

            List<String> idsList = new ArrayList<>();
            if (!ids.equals("All")){
                String[] arr = ids.split(",");
                for (String s : arr) {
                    idsList.add(s);
                }

                wrapper.in("id",idsList);
            }

            List<Map<String,Object>> mapList = new ArrayList<>();


            Wrapper wrapper1 = new EntityWrapper<TOrderPrivateCar>().eq("state",7).eq("driverId",driverId).gt("payMoney",0);
            ///   快车
            List<TOrderPrivateCar> list = privateCarService.selectList(wrapper1);
            for (TOrderPrivateCar tOrderPrivateCar : list) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "快车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }


            Wrapper wrapper2 = new EntityWrapper<TOrderTaxi>().eq("state",7).eq("driverId",driverId).gt("payMoney",0);

            ///   出租车
            List<TOrderTaxi> list1 = taxiService.selectList(wrapper2);
            for (TOrderTaxi tOrderPrivateCar : list1) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "出租车");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }


            Wrapper wrapper6 = new EntityWrapper<TOrderCall>().eq("state",7).eq("driverId",driverId).gt("payMoney",0);

            ///   95128电召
            List<TOrderCall> list5 = orderCallService.selectList(wrapper6);
            for (TOrderCall tOrderPrivateCar : list5) {
                Map<String,Object> map = new HashMap<>();
                map.put("id", tOrderPrivateCar.getId());
                map.put("endServiceTime", DateUtil.getTime(tOrderPrivateCar.getEndServiceTime()));
                map.put("orderType", "95128电召");
                map.put("orderNum", tOrderPrivateCar.getOrderNum());
                map.put("orderMoney", tOrderPrivateCar.getOrderMoney());
                TSysWithdrawalPoundage sysWithdrawalPoundage = withdrawalPoundageService.selectOne(new EntityWrapper<TSysWithdrawalPoundage>().ne("id",0));
                map.put("driverOrderEarningMoney", tOrderPrivateCar.getOrderMoney().doubleValue() * sysWithdrawalPoundage.getPercentage() / 100);
                mapList.add(map);
            }

            System.out.println(mapList);

            String[][] values = new String[mapList.size()][];
            for (int i = 0; i < mapList.size(); i++) {
                Map<String,Object> d=mapList.get(i);
                values[i] = new String[title.length];
                values[i][0]=d.get("id").toString();

                if (ToolUtil.isNotEmpty(d.get("endServiceTime"))){
                    values[i][1]=d.get("endServiceTime").toString();
                }else {
                    values[i][1]="";
                }

                if (ToolUtil.isNotEmpty(d.get("orderType"))){
                    values[i][2]=d.get("orderType").toString();
                }else {
                    values[i][2] = "";
                }

                if (ToolUtil.isNotEmpty(d.get("orderNum"))){
                    values[i][3]=d.get("orderNum").toString();
                }else {
                    values[i][3] = "";
                }

                if (ToolUtil.isNotEmpty(d.get("orderMoney"))){
                    values[i][4]=d.get("orderMoney").toString();
                }else {
                    values[i][4] = "";
                }

                if (ToolUtil.isNotEmpty(d.get("driverOrderEarningMoney"))){
                    values[i][5]=d.get("driverOrderEarningMoney").toString();
                }else {
                    values[i][5] = "";
                }
            }
            String fileNameTitle="订单未收明细";
            HSSFWorkbook wb = ExcelUtil.getHSSFWorkbook(fileNameTitle+time, title, values, null);
            ExcelUtil.setResponseHeader(response, fileName);
            OutputStream os = response.getOutputStream();
            wb.write(os);
            os.flush();
            os.close();

        } catch (Exception e) {
            e.printStackTrace();
            /*return ApiUtil.putFailObj("导出失败");*/
        }
        return SUCCESS_TIP;
    }



    /**
     * 订单提现明细导出
     */
    @RequestMapping(value = "/exportRecordxxxxx")
    @ResponseBody
    public Object exportRecordxxxxx(HttpServletResponse response,@RequestParam String ids,@RequestParam Integer driverId) {
        try {

            Wrapper wrapper = new EntityWrapper<TPubWithdrawal>().eq("type",2).eq("userId",driverId).eq("state",2).eq("userType",2).orderBy("id",false);

            Date date = new Date();
            DateFormat format = new SimpleDateFormat("yyyyMMdd");
            String time = format.format(date);
            String fileName = "订单提现明细"+time+".xls";
            String[] title = new String[] {"序号","时间","提现金额"};

            List<String> idsList = new ArrayList<>();
            if (!ids.equals("All")){
                String[] arr = ids.split(",");
                for (String s : arr) {
                    idsList.add(s);
                }

                wrapper.in("id",idsList);
            }

            List<Map<String,Object>> mapList = pubWithdrawalService.selectMaps(wrapper);

            System.out.println(mapList);

            String[][] values = new String[mapList.size()][];
            for (int i = 0; i < mapList.size(); i++) {
                Map<String,Object> d=mapList.get(i);
                values[i] = new String[title.length];
                values[i][0]=d.get("id").toString();

                if (ToolUtil.isNotEmpty(d.get("handleTime").toString())){
                    values[i][1]=d.get("handleTime").toString();
                }else {
                    values[i][1]="";
                }

                if (ToolUtil.isNotEmpty(d.get("money").toString())){
                    values[i][2]=d.get("money").toString();
                }else {
                    values[i][2] = "0";
                }
            }
            String fileNameTitle="订单提现明细";
            HSSFWorkbook wb = ExcelUtil.getHSSFWorkbook(fileNameTitle+time, title, values, null);
            ExcelUtil.setResponseHeader(response, fileName);
            OutputStream os = response.getOutputStream();
            wb.write(os);
            os.flush();
            os.close();

        } catch (Exception e) {
            e.printStackTrace();
            /*return ApiUtil.putFailObj("导出失败");*/
        }
        return SUCCESS_TIP;
    }


    /**
     * 获取司机订单收益明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @return
     */
    @PostMapping("/orderRevenueDetailsList")
    @ResponseBody
    public Object orderRevenueDetailsList(String driverName, String driverPhone, String createTime, Integer orderType){
        Page<Map<String, Object>> page = new PageFactory<Map<String, Object>>().defaultPage();
        List<Map<String, Object>> list = driverService.orderRevenueDetailsList(page, driverName, driverPhone, createTime, orderType);
        page.setRecords(list);
        return super.packForBT(page);
    }


    /**
     * 导出司机订单收益明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param response
     */
    @GetMapping("/exportOrderRevenueDetails")
    @ResponseBody
    public void exportOrderRevenueDetails(String driverName, String driverPhone, String createTime, Integer orderType, HttpServletResponse response){
        try {
            HSSFWorkbook hssfWorkbook = driverService.exportOrderRevenueDetails(driverName, driverPhone, createTime, orderType);
            ExcelUtil.setResponseHeader(response, "司机订单收益明细.xls");
            OutputStream os = response.getOutputStream();
            hssfWorkbook.write(os);
            os.flush();
            os.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 司机订单提现明细
     * @return
     */
    @GetMapping("/showOrderWithdrawalDetails")
    public String showOrderWithdrawalDetails(){
        return PREFIX + "orderWithdrawalDetails.html";
    }


    /**
     * 获取司机提现明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param offset
     * @param limit
     * @return
     */
    @ResponseBody
    @PostMapping("/orderWithdrawalDetailsList")
    public Object orderWithdrawalDetailsList(String driverName, String driverPhone, String createTime, Integer offset, Integer limit){
        try {
            return pubWithdrawalService.orderWithdrawalDetailsList(driverName, driverPhone, createTime, offset, limit);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 导出司机订单提现明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param response
     */
    @ResponseBody
    @GetMapping("/exportOrderWithdrawalDetails")
    public void exportOrderWithdrawalDetails(String driverName, String driverPhone, String createTime, HttpServletResponse response){
        try {
            HSSFWorkbook hssfWorkbook = pubWithdrawalService.exportOrderWithdrawalDetails(driverName, driverPhone, createTime);
            ExcelUtil.setResponseHeader(response, "订单提现明细.xls");
            OutputStream os = response.getOutputStream();
            hssfWorkbook.write(os);
            os.flush();
            os.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 跳转奖励明细
     * @return
     */
    @GetMapping("/showRewardDetails")
    public String showRewardDetails(){
        return PREFIX + "rewardDetails.html";
    }


    /**
     * 获取司机活动收益明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param offset
     * @param limit
     * @return
     */
    @ResponseBody
    @PostMapping("/rewardDetailsList")
    public Object rewardDetailsList(String driverName, String driverPhone, String createTime, Integer offset, Integer limit){
        try {
            return driverActivityHistoryService.rewardDetailsList(driverName, driverPhone, createTime, offset, limit);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 导出司机奖励明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param response
     */
    @ResponseBody
    @GetMapping("/exportRewardDetails")
    public void exportRewardDetails(String driverName, String driverPhone, String createTime, HttpServletResponse response){
        try {
            HSSFWorkbook hssfWorkbook = driverActivityHistoryService.exportRewardDetails(driverName, driverPhone, createTime);
            ExcelUtil.setResponseHeader(response, "奖励明细.xls");
            OutputStream os = response.getOutputStream();
            hssfWorkbook.write(os);
            os.flush();
            os.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 跳转司机活动提现明细
     * @return
     */
    @GetMapping("/showRewardWithdrawalDetails")
    public String showRewardWithdrawalDetails(){
        return PREFIX + "rewardWithdrawalDetails.html";
    }

    /**
     * 司机奖励提现明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param offset
     * @param limit
     * @return
     */
    @ResponseBody
    @PostMapping("/rewardWithdrawalDetailsList")
    public Object rewardWithdrawalDetailsList(String driverName, String driverPhone, String createTime, Integer offset, Integer limit){
        try {
            return pubWithdrawalService.rewardWithdrawalDetailsList(driverName, driverPhone, createTime, offset, limit);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 导出司机奖励提现明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param response
     */
    @ResponseBody
    @GetMapping("/exportRewardWithdrawalDetails")
    public void exportRewardWithdrawalDetails(String driverName, String driverPhone, String createTime, HttpServletResponse response){
        try {
            HSSFWorkbook hssfWorkbook = pubWithdrawalService.exportRewardWithdrawalDetails(driverName, driverPhone, createTime);
            ExcelUtil.setResponseHeader(response, "奖励提现明细.xls");
            OutputStream os = response.getOutputStream();
            hssfWorkbook.write(os);
            os.flush();
            os.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 跳转到平台其他支出明细
     * @return
     */
    @GetMapping("/showOtherSpendingDetail")
    public String showOtherSpendingDetail(){
        return PREFIX + "otherSpendingDetail.html";
    }


    /**
     * 获取平台其他支出明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param offset
     * @param limit
     * @return
     */
    @ResponseBody
    @PostMapping("/otherSpendingDetailList")
    public Object otherSpendingDetailList(String driverName, String driverPhone, String createTime, Integer offset, Integer limit){
        try {
            return driverService.otherSpendingDetailList(driverName, driverPhone, createTime, offset, limit);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 导出平台其他支出明细
     * @param driverName
     * @param driverPhone
     * @param createTime
     * @param response
     */
    @ResponseBody
    @GetMapping("/exportOtherSpendingDetailList")
    public void exportOtherSpendingDetailList(String driverName, String driverPhone, String createTime, HttpServletResponse response){
        try {
            HSSFWorkbook hssfWorkbook = driverService.exportOtherSpendingDetailList(driverName, driverPhone, createTime);
            ExcelUtil.setResponseHeader(response, "平台其他支出明细.xls");
            OutputStream os = response.getOutputStream();
            hssfWorkbook.write(os);
            os.flush();
            os.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}