package com.glxp.api.controller.thrsys;

import org.springframework.beans.BeanUtils;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.github.pagehelper.PageInfo;
import com.glxp.api.annotation.AuthRuleAnnotation;
import com.glxp.api.common.enums.ResultEnum;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.BasicProcessStatus;
import com.glxp.api.constant.Constant;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.entity.thrsys.*;
import com.glxp.api.http.ErpOrderClient;
import com.glxp.api.http.HttpOkClient;
import com.glxp.api.req.inout.FilterOrderRequest;
import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.req.thrsys.*;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.thrsys.ThrOrderResponse;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.service.thrsys.*;
import com.glxp.api.util.CustomUtil;
import com.glxp.api.util.RedisUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@RestController
public class ThrOrderController {
    @Resource
    private ThrOrderService thrOrderService;
    @Resource
    private ThrOrderDetailService thrOrderDetailService;
    @Resource
    private ThrOrdersDlService thrOrdersDlService;
    @Resource
    private ThrOrderImportLogService thrOrderImportLogService;
    @Resource
    private ThrOrderImportDetailService thrOrderImportDetailService;
    @Resource
    RedisUtil redisUtil;
    @Resource
    private SystemParamConfigService systemParamConfigService;
    @Resource
    private IThrBusTypeOriginService iThrBusTypeOriginService;
    @Resource
    ErpOrderClient erpOrderClient;
    @Resource
    HttpOkClient httpOkClient;

    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/thrsys/getOrders")
    public BaseResponse getOrders(FilterThrOrderRequest filterThrOrderRequest,
                                  BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        List<ThrOrderEntity> thrOrderEntities
                = thrOrderService.filterThrOrder(filterThrOrderRequest);
        PageInfo<ThrOrderEntity> pageInfo;
        pageInfo = new PageInfo<>(thrOrderEntities);
        PageSimpleResponse<ThrOrderEntity> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(thrOrderEntities);
        return ResultVOUtils.success(pageSimpleResponse);
    }

    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/thrsys/getOrderDetails")
    public BaseResponse getOrderDetails(FilterThrOrderDetailRequest filterThrOrderDetailRequest,
                                        BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        List<ThrOrderDetailEntity> thrOrderDetailEntities
                = thrOrderDetailService.filterThrOrderDetailDetail(filterThrOrderDetailRequest);
        PageInfo<ThrOrderDetailEntity> pageInfo;
        pageInfo = new PageInfo<>(thrOrderDetailEntities);
        PageSimpleResponse<ThrOrderDetailEntity> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(thrOrderDetailEntities);
        return ResultVOUtils.success(pageSimpleResponse);
    }

    @AuthRuleAnnotation("")
    @PostMapping("/udiwms/thrsys/postOrderDetail")
    public BaseResponse postOrderDetail(@RequestBody PostThrOrderRequest postThrOrderRequest,
                                        BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        String genKey = postThrOrderRequest.getGenKey();
        if (genKey == null) {
            genKey = CustomUtil.getId();
        }
        ThrOrderImportLogEntity thrOrderImportLogEntity = thrOrderImportLogService.selectByGenKey(genKey);
        if (thrOrderImportLogEntity == null) {
            thrOrderImportLogEntity = new ThrOrderImportLogEntity();
            thrOrderImportLogEntity.setGenKey(genKey);
            if (postThrOrderRequest.getUploadType() != null) {
                thrOrderImportLogEntity.setFromType("文件上传");
            } else
                thrOrderImportLogEntity.setFromType("第三方系统上传");
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_UNPROCESS);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogEntity.setThirdSysFk(postThrOrderRequest.getThirdSys());
            thrOrderImportLogService.insertImportLog(thrOrderImportLogEntity);
        }
        List<ThrOrderResponse> erpOrderResponses = postThrOrderRequest.getDatas();
        if (erpOrderResponses != null && erpOrderResponses.size() > 0) {
            List<ThrOrderImportDetailEntity> thrOrderImportDetailEntities = new ArrayList<>();
            String finalGenKey = genKey;
            for (ThrOrderResponse erpOrderResponse : erpOrderResponses) {
                List<ThrOrderResponse.SubErpOrder> subErpOrders = erpOrderResponse.getSubErpOrders();
                if (subErpOrders != null && subErpOrders.size() > 0) {
                    for (ThrOrderResponse.SubErpOrder subErpOrder : subErpOrders) {
                        ThrOrderImportDetailEntity thrOrderDetailEntity = new ThrOrderImportDetailEntity();
                        BeanUtils.copyProperties(erpOrderResponse, thrOrderDetailEntity);
                        BeanUtils.copyProperties(subErpOrder, thrOrderDetailEntity);
                        thrOrderDetailEntity.setGenKeyFk(finalGenKey);
                        thrOrderDetailEntity.setThirdSysFk(postThrOrderRequest.getThirdSys());
                        thrOrderDetailEntity.setUpdateTime(new Date());
                        thrOrderImportDetailEntities.add(thrOrderDetailEntity);
                    }

                }
            }
            thrOrderImportDetailService.insertOrderImportDetails(thrOrderImportDetailEntities);
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_UNPROCESS);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogService.updateImportLog(thrOrderImportLogEntity);
            thrOrderImportLogService.importThrOrder(finalGenKey);
        } else {
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_FAIL);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogService.updateImportLog(thrOrderImportLogEntity);
            return ResultVOUtils.error(500, "上传数据为空");
        }
        return ResultVOUtils.success("单据上传成功！");
    }

    @PostMapping("/udiwms/thrsys/postFileOrder")
    public BaseResponse postFileOrder(@RequestBody PostFileThrOrderRequest postThrOrderRequest,
                                      BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        String genKey = postThrOrderRequest.getGenKey();
        if (genKey == null) {
            genKey = CustomUtil.getId();
        }
        ThrOrderImportLogEntity thrOrderImportLogEntity = thrOrderImportLogService.selectByGenKey(genKey);
        if (thrOrderImportLogEntity == null) {
            thrOrderImportLogEntity = new ThrOrderImportLogEntity();
            thrOrderImportLogEntity.setGenKey(genKey);
            if (postThrOrderRequest.getUploadType() != null) {
                thrOrderImportLogEntity.setFromType("文件上传");
            } else
                thrOrderImportLogEntity.setFromType("第三方系统上传");
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_UNPROCESS);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogEntity.setThirdSysFk(postThrOrderRequest.getThirdSys());
            thrOrderImportLogService.insertImportLog(thrOrderImportLogEntity);
        }
        List<ThrOrderImportDetailEntity> thrOrderImportDetailEntities = postThrOrderRequest.getDatas();
        if (thrOrderImportDetailEntities != null && thrOrderImportDetailEntities.size() > 0) {
            String finalGenKey = genKey;
            for (ThrOrderImportDetailEntity thrOrderImportDetailEntity : thrOrderImportDetailEntities) {
                thrOrderImportDetailEntity.setThirdSysFk(postThrOrderRequest.getThirdSys());
                thrOrderImportDetailEntity.setGenKeyFk(genKey);
                thrOrderImportDetailEntity.setStatus(String.valueOf(BasicProcessStatus.UDIINFO_IMPORT_CODE_UNPROCESS));
                thrOrderImportDetailEntity.setUpdateTime(new Date(System.currentTimeMillis()));
            }
            thrOrderImportDetailService.insertOrderImportDetails(thrOrderImportDetailEntities);
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_UNPROCESS);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogService.updateImportLog(thrOrderImportLogEntity);
            thrOrderImportLogService.importThrOrder(finalGenKey);
        } else {
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_FAIL);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogService.updateImportLog(thrOrderImportLogEntity);
            return ResultVOUtils.error(500, "上传数据为空");
        }
        return ResultVOUtils.success("单据上传成功！");
    }


    @PostMapping("/udiwms/thrsys/delOrder")
    public BaseResponse delOrder(@RequestBody DeleteRequest deleteRequest, BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        String id = deleteRequest.getId();
        ThrOrderEntity thrOrderEntity = thrOrderService.findById(Integer.parseInt(id));
        String msg = selectDelect(thrOrderEntity);
        if (msg == null) {
            boolean b = thrOrderService.deleteById(id);
            thrOrderDetailService.deleteByOrderIdFk(thrOrderEntity.getBillNo() + "");
            if (b)
                return ResultVOUtils.success("删除成功");
            else return ResultVOUtils.error(500, "无法删除！");
        } else return ResultVOUtils.error(500, msg);

    }


    @AuthRuleAnnotation("")
    @PostMapping("/udiwms/thrsys/delOrderDetail")
    public BaseResponse delOrderDetail(@RequestBody DeleteRequest deleteRequest, BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        boolean b = thrOrderDetailService.deleteById(deleteRequest.getId());
        if (b)
            return ResultVOUtils.success("删除成功");
        else return ResultVOUtils.error(500, "无法删除！");

    }

    public String selectDelect(ThrOrderEntity thrOrderEntity) {
        FilterThrOrderRequest filterErpOrderRequest = new FilterThrOrderRequest();
        //todo  单据类型还没设计好
//        filterErpOrderRequest.setErpOrderId(thrOrderEntity.getBillNo());
//        List<ThrErpOrderResponse> erpOrderEntities = myErpOrderService.filterAllMyErpOrder(filterErpOrderRequest);
//        if (erpOrderEntities != null && erpOrderEntities.size() > 0) {
//            return "单据" + thrOrderEntity.getBillNo() + "已于出入库单据关联，无法删除";
//        } else {
//            return null;
//        }
        return null;
    }

    @AuthRuleAnnotation("")
    @RequestMapping("/udiwms/thrsys/order/delAll")
    public BaseResponse delAll() {
        thrOrderService.deleteAll();
        thrOrderDetailService.deleteAll();
        return ResultVOUtils.success("删除成功");
    }

    @AuthRuleAnnotation("")
    @RequestMapping("/udiwms/thrsys/orders/downloadAll")
    public BaseResponse downloadAll(FilterThrOrderRequest filterThrProductsRequest) {
        String data = (String) redisUtil.get(Constant.dlThrOrders);
        if (false) {//(data != null && data.equals("true")) {
            return ResultVOUtils.error(500, "当前任务正在下载更新业务单据信息，请稍后重试！");
        } else {
            redisUtil.set(Constant.dlThrOrders, "true", 10 * 30);
            if (filterThrProductsRequest.getBillAction() == null) {
                return ResultVOUtils.error(500, "未选择业务类型！");
            }

            ThrOrderImportLogEntity thrOrderImportLogEntity = new ThrOrderImportLogEntity();
            String genKey = CustomUtil.getId();
            thrOrderImportLogEntity.setGenKey(genKey);
            thrOrderImportLogEntity.setFromType("第三方系统获取");
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_UNPROCESS);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogEntity.setThirdSysFk(filterThrProductsRequest.getThirdSysFk());
            thrOrderImportLogService.insertImportLog(thrOrderImportLogEntity);
            if (filterThrProductsRequest.getErpOrderResponses() != null) {//选中导出
                thrOrdersDlService.importSelectOrders(genKey, filterThrProductsRequest.getErpOrderResponses(), filterThrProductsRequest.getThirdSysFk());
            } else {        //结果导出
                thrOrdersDlService.importOrders(genKey, filterThrProductsRequest.getBillAction(), null);
            }
            return ResultVOUtils.success("后台开始下载更新，请稍后刷新查看");
        }
    }

    @AuthRuleAnnotation("")
    @PostMapping("/udiwms/thrsys/orders/orderDownload")
    public BaseResponse orderDownload(@RequestBody FilterThrOrderRequest filterThrProductsRequest) {
        String data = (String) redisUtil.get(Constant.dlThrOrders);
        if ((data != null && data.equals("true"))) {
            return ResultVOUtils.error(500, "当前任务正在下载更新业务单据信息，请稍后重试！");
        } else {
            redisUtil.set(Constant.dlThrOrders, "true", 1 * 60);
            if (filterThrProductsRequest.getBillAction() == null) {
                return ResultVOUtils.error(500, "未选择业务类型！");
            }
            ThrOrderImportLogEntity thrOrderImportLogEntity = new ThrOrderImportLogEntity();
            String genKey = CustomUtil.getId();
            thrOrderImportLogEntity.setGenKey(genKey);
            thrOrderImportLogEntity.setFromType("第三方系统获取");
            thrOrderImportLogEntity.setStatus(BasicProcessStatus.UDIINFO_IMPORT_UNPROCESS);
            thrOrderImportLogEntity.setUpdateTime(new Date());
            thrOrderImportLogEntity.setThirdSysFk(filterThrProductsRequest.getThirdSysFk());
            thrOrderImportLogService.insertImportLog(thrOrderImportLogEntity);
            if (filterThrProductsRequest.getErpOrderResponses() != null && filterThrProductsRequest.getErpOrderResponses().size() > 0) {//选中导出
                thrOrdersDlService.importSelectOrders(genKey, filterThrProductsRequest.getErpOrderResponses(), filterThrProductsRequest.getThirdSysFk());
            } else {        //结果导出
                thrOrdersDlService.importOrders(genKey, filterThrProductsRequest.getBillAction(), filterThrProductsRequest);
            }
            return ResultVOUtils.success("后台开始下载更新，请稍后刷新查看");
        }
    }

    @AuthRuleAnnotation("")
    @PostMapping("/udiwms/smp/postOrder")
    public BaseResponse postSmpOrder(@RequestBody PostSmpOrderRequest postSmpOrderRequest,
                                     BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }

        SystemParamConfigEntity systemParamConfigEntity = systemParamConfigService.selectByParamKey("smp_uploadOrder_url");
        String postUrl;
        if (systemParamConfigEntity == null)
            return ResultVOUtils.error(500, "上传供应商平台接口地址未定义");
        else
            postUrl = systemParamConfigEntity.getParamValue();

        List<String> ids = postSmpOrderRequest.getIds();
        for (String id : ids) {
            ThrOrderEntity thrOrderEntity = thrOrderService.findById(Integer.parseInt(id));
            UploadSmpRequest uploadSmpRequest = new UploadSmpRequest();
            BeanUtils.copyProperties(thrOrderEntity, uploadSmpRequest);
            uploadSmpRequest.setType(1);
            FilterThrOrderDetailRequest filterThrOrderDetailRequest = new FilterThrOrderDetailRequest();
            filterThrOrderDetailRequest.setOrderIdFk(id);
            List<ThrOrderDetailEntity> thrOrderDetailEntities = thrOrderDetailService.filterThrOrderDetailDetail(filterThrOrderDetailRequest);
            if (thrOrderDetailEntities != null && thrOrderDetailEntities.size() > 0) {
                List<UploadSmpRequest.SubErpOrder> subErpOrders = new ArrayList<>();
                for (ThrOrderDetailEntity thrOrderDetailEntity : thrOrderDetailEntities) {
                    UploadSmpRequest.SubErpOrder subErpOrder = new UploadSmpRequest.SubErpOrder();
                    BeanUtils.copyProperties(thrOrderDetailEntity, subErpOrder);
                    subErpOrders.add(subErpOrder);
                }
                uploadSmpRequest.setSubErpOrders(subErpOrders);

                String response = httpOkClient.uCloudPost(postUrl, uploadSmpRequest);
                BaseResponse baseResponse =
                        JSONObject.parseObject(response, new TypeReference<BaseResponse>() {
                        });
                if (baseResponse.getCode() == 20000) {
                    return ResultVOUtils.success("上传成功！");
                } else {
                    return ResultVOUtils.error(baseResponse.getCode(), baseResponse.getMessage());
                }
            }
        }
        return ResultVOUtils.error(500, "上传数据成功");
    }

    //只查询第三方单据
    @PostMapping("/udiwms/thirdOrder/filter")
    public BaseResponse filterThirdOrder(@RequestBody FilterThrOrderRequest filterErpOrderRequest,
                                         BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }

        if (filterErpOrderRequest.getIsDownThrSys()) {
            BaseResponse<PageSimpleResponse<ThrOrderResponse>> responseBaseResponse = erpOrderClient.getThrOrderResponse(filterErpOrderRequest);
            return responseBaseResponse;
        }


        ThrSystemDetailEntity thrSystemDetailEntity = iThrBusTypeOriginService.findSysByAction(filterErpOrderRequest.getBillAction(), "orderQueryUrl");
        filterErpOrderRequest.setThirdOrderFk(thrSystemDetailEntity.getThirdSysFk());
        if (thrSystemDetailEntity == null || !thrSystemDetailEntity.getEnabled()) {
            return ResultVOUtils.error(500, "第三方系统业务单据接口服务未启用");
        }

        if (thrSystemDetailEntity.getThirdSysFk() == null) {
            return ResultVOUtils.error(500, "第三方业务单据服务未关联");
        }


        FilterThrOrderRequest filterThrOrderRequest = new FilterThrOrderRequest();
        BeanUtils.copyProperties(filterErpOrderRequest, filterThrOrderRequest);
        filterThrOrderRequest.setPage(filterErpOrderRequest.getPage());
        filterThrOrderRequest.setLimit(filterErpOrderRequest.getLimit());
        List<ThrOrderResponse> erpOrderResponses = new ArrayList<>();
        List<ThrOrderEntity> data = thrOrderService.filterThrOrder(filterThrOrderRequest);
        if (data != null && data.size() > 0) {
            for (ThrOrderEntity thrOrderEntity : data) {
                FilterThrOrderDetailRequest filterThrOrderDetailRequest = new FilterThrOrderDetailRequest();
                filterThrOrderDetailRequest.setOrderIdFk(thrOrderEntity.getBillNo() + "");
                List<ThrOrderDetailEntity> thrOrderDetailEntities = thrOrderDetailService.filterThrOrderDetailDetail(filterThrOrderDetailRequest);
                ThrOrderResponse erpOrderResponse = new ThrOrderResponse();
                BeanUtils.copyProperties(thrOrderEntity, erpOrderResponse);
                List<ThrOrderResponse.SubErpOrder> subErpOrders = new ArrayList<>();
                if (thrOrderDetailEntities != null && thrOrderDetailEntities.size() > 0) {
                    for (ThrOrderDetailEntity thrOrderDetailEntity : thrOrderDetailEntities) {
                        ThrOrderResponse.SubErpOrder subErpOrder = new ThrOrderResponse.SubErpOrder();
                        BeanUtils.copyProperties(thrOrderDetailEntity, subErpOrder);
                        subErpOrders.add(subErpOrder);
                    }
                }
                erpOrderResponse.setSubErpOrders(subErpOrders);
                erpOrderResponses.add(erpOrderResponse);
            }
        }
        //todo 单据表还未设计好
//        if (thrSystemDetailEntity.getLocalAction() != null) {
//            BaseResponse<PageSimpleResponse<ThrOrderResponse>> loca = getLoaclData(filterErpOrderRequest);
//            erpOrderResponses.addAll(loca.getData().getList());
//        }
        PageInfo<ThrOrderEntity> pageInfo;
        pageInfo = new PageInfo<>(data);
        PageSimpleResponse<ThrOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(erpOrderResponses);
        return ResultVOUtils.success(pageSimpleResponse);

    }


    @AuthRuleAnnotation("")
    @GetMapping("/spms/erpOrder/filter")
    public BaseResponse filterSpmsOrder(FilterOrderRequest filterErpOrderRequest,
                                        BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        FilterThrOrderRequest filterThrOrderRequest = new FilterThrOrderRequest();
        BeanUtils.copyProperties(filterErpOrderRequest, filterThrOrderRequest);
        filterThrOrderRequest.setPage(filterErpOrderRequest.getPage());
        filterThrOrderRequest.setLimit(filterErpOrderRequest.getLimit());

        List<ThrOrderResponse> erpOrderResponses = new ArrayList<>();
        List<ThrOrderEntity> data = thrOrderService.filterThrOrder(filterThrOrderRequest);
        if (data != null && data.size() > 0) {
            for (ThrOrderEntity thrOrderEntity : data) {
                FilterThrOrderDetailRequest filterThrOrderDetailRequest = new FilterThrOrderDetailRequest();
                filterThrOrderDetailRequest.setOrderIdFk(thrOrderEntity.getId() + "");
                List<ThrOrderDetailEntity> thrOrderDetailEntities =
                        thrOrderDetailService.filterThrOrderDetailDetail(filterThrOrderDetailRequest);
                ThrOrderResponse erpOrderResponse = new ThrOrderResponse();
                BeanUtils.copyProperties(thrOrderEntity, erpOrderResponse);
                List<ThrOrderResponse.SubErpOrder> subErpOrders = new ArrayList<>();
                if (thrOrderDetailEntities != null && thrOrderDetailEntities.size() > 0) {
                    for (ThrOrderDetailEntity thrOrderDetailEntity : thrOrderDetailEntities) {
                        ThrOrderResponse.SubErpOrder subErpOrder = new ThrOrderResponse.SubErpOrder();
                        BeanUtils.copyProperties(thrOrderDetailEntity, subErpOrder);
                        subErpOrder.setCount(thrOrderDetailEntity.getCount());
                        subErpOrder.setReCount(thrOrderDetailEntity.getReCount());
                        subErpOrders.add(subErpOrder);
                    }
                }
                erpOrderResponse.setSubErpOrders(subErpOrders);
                erpOrderResponses.add(erpOrderResponse);
            }
        }
        PageInfo<ThrOrderEntity> pageInfo;
        pageInfo = new PageInfo<>(data);
        PageSimpleResponse<ThrOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(erpOrderResponses);
        return ResultVOUtils.success(pageSimpleResponse);
    }


}