meidu2021/daju/target/classes/cn/com/lzt/sign/controller/TBMaterialController.java

package cn.com.lzt.sign.controller;

import cn.com.lzt.arrangedutyoperate.dto.UserAndUserPersonnelDto;
import cn.com.lzt.car.cardoc.entity.CarEntity;
import cn.com.lzt.goodscategory.entity.TBGoodsCategoryEntity;
import cn.com.lzt.goodsinfo.entity.TBGoodsInfoEntity;
import cn.com.lzt.goodsinfo.service.TBGoodsInfoServiceI;
import cn.com.lzt.sign.entity.*;
import cn.com.lzt.sign.page.TBMaterialPage;
import cn.com.lzt.sign.service.*;
import cn.com.lzt.useractiviti.data.dao.UseractivitiDataDao;
import cn.com.lzt.useroptions.service.TBusUserOptionsServiceI;
import cn.com.lzt.warehouse.entity.WarehouseEntity;
import cn.com.lzt.warehouse.service.WarehouseServiceI;

import java.io.*;
import java.net.URLEncoder;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import com.alibaba.fastjson.JSONObject;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.util.CellRangeAddress;
import org.jeecgframework.core.common.controller.BaseController;
import org.jeecgframework.core.common.exception.BusinessException;
import org.jeecgframework.core.common.hibernate.qbc.CriteriaQuery;
import org.jeecgframework.core.common.model.json.AjaxJson;
import org.jeecgframework.core.common.model.json.DataGrid;
import org.jeecgframework.core.constant.Globals;
import org.jeecgframework.core.extend.hqlsearch.HqlGenerateUtil;
import org.jeecgframework.core.util.ContextHolderUtils;
import org.jeecgframework.core.util.ResourceUtil;
import org.jeecgframework.core.util.StringUtil;
import org.jeecgframework.tag.core.easyui.TagUtil;
import org.jeecgframework.tag.vo.datatable.SortDirection;
import org.jeecgframework.web.cgform.service.migrate.MigrateForm;
import org.jeecgframework.web.system.pojo.base.*;
import org.jeecgframework.web.system.service.SystemService;
import org.jeecgframework.web.system.util.Tool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;


@Controller
@RequestMapping({"/tBMaterialController"})
public class TBMaterialController extends BaseController {
    private static final Logger logger = Logger.getLogger(String.valueOf(cn.com.lzt.sign.controller.TBMaterialController.class));


    @Autowired
    private TBMaterialService tBMaterialService;
    @Autowired
    private TBMaterialService TBMaterialInfoService;

    @Autowired
    private WarehouseServiceI warehouseService;

    @Autowired
    private TBusUserOptionsServiceI userOptionsService;

    @Autowired
    private TBGoodsInfoServiceI tBGoodsInfoService;

    @Autowired
    private UseractivitiDataDao useractivitiDataDao;

    @Autowired
    private SystemService systemService;

    @Autowired
    private TBMaterialArrivalService tbMaterialArrivalService;

    @Autowired
    private TBMaterialDeliveryService tbMaterialDeliveryService;

    @Autowired
    private TBMaterialDeliveryInfoService tbMaterialDeliveryInfoService;

    @Autowired
    private TBMaterialStockOnHandService tbMaterialStockOnHandService;

    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    //物料申购页面跳转
    @RequestMapping(params = {"list"})
    public ModelAndView list(HttpServletRequest request) {
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/tBMaterialList");
    }

    //物料采购页面跳转
    @RequestMapping(params = {"materialPurchasingList"})
    public ModelAndView materialPurchasingList(HttpServletRequest request) {
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialPurchasingList");
    }

    //物料到货页面跳转
    @RequestMapping(params = {"materialArrivalList"})
    public ModelAndView materialArrivalList(HttpServletRequest request) {
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialArrivalList");
    }

    //物料出货页面跳转
    @RequestMapping(params = {"materialDeliveryList"})
    public ModelAndView materialDeliveryList(HttpServletRequest request) {
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialDeliveryList");
    }

    //物料现存量页面跳转
    @RequestMapping(params = {"materialStockOnHandList"})
    public ModelAndView materialStockOnHandList(HttpServletRequest request) {
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialStockOnHandList");
    }

    /**
     * 获取当前登录人的审批权限集合
     *
     * @return
     * @author刘梦祥
     * @Date 2021年11月29日00:42:57
     */
    public Map<String, List<String>> getUserRuleMap() {
        //          获取当前操作人的信息
        TSUser user = ResourceUtil.getSessionUser();
        CriteriaQuery criteriaQuery = new CriteriaQuery(TSUserOrg.class, new DataGrid());
        criteriaQuery.eq("tsUser.id", user.getId());
        criteriaQuery.add();
        List<TSUserOrg> tsUserOrgList = this.systemService.getListByCriteriaQuery(criteriaQuery, true);
        DataGrid dataGrid1 = new DataGrid();
        CriteriaQuery criteriaQuery1 = new CriteriaQuery(UserAndUserPersonnelDto.class, dataGrid1);
        criteriaQuery1.eq("userid", user.getId());
        criteriaQuery1.add();
        List<UserAndUserPersonnelDto> userAndUserPersonnelDtoList = this.systemService.getListByCriteriaQuery(criteriaQuery1, true);
        Map<String, List<String>> ruleMap = new HashMap<>();
//      得到登录人的科室
        List<String> departidList = new ArrayList<>();
        if (tsUserOrgList != null && tsUserOrgList.size() > 0) {
            for (TSUserOrg tsUserOrg : tsUserOrgList) {
                departidList.add(tsUserOrg.getTsDepart().getId());
            }
        } else {
            System.err.println("用户的科室信息查询失败：用户id：" + user.getId());
        }
//      得到操作人的岗位
        List<String> inPostidList = new ArrayList<>();
        if (userAndUserPersonnelDtoList != null && userAndUserPersonnelDtoList.size() > 0) {
            for (UserAndUserPersonnelDto userInfoDto : userAndUserPersonnelDtoList) {
                if (StringUtil.isNotEmpty(userInfoDto.getInPostid())) {
                    if (!inPostidList.contains(userInfoDto.getInPostid())) {
                        inPostidList.add(userInfoDto.getInPostid());
                    }
                }
            }
        } else {
            System.err.println("用户的岗位信息查询失败：用户id：" + user.getId());
        }
        ruleMap.put("departId", departidList);
        ruleMap.put("inPostid", inPostidList);
        return ruleMap;
    }

    //物料申购页面数据请求(add-刘梦祥-2021年11月27日15:13:19-（添加逻辑：如果该采购单已经到货，就不再显示）)
    @RequestMapping(params = {"datagrid"})
    public void datagrid(TBMaterialEntity tBMaterial, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        StringBuffer queryStr = new StringBuffer();
        queryStr.append(" where 1 = 1 ");
        //          封装请购科室查询条件
        if (StringUtil.isNotEmpty(request.getParameter("materialDaptId"))) {
            queryStr.append(" and material_dapt_id = \"" + request.getParameter("materialDaptId") + "\"");
        }
        //          封装请购科室查询条件
        if (StringUtil.isNotEmpty(request.getParameter("materialWarehouseId"))) {
            queryStr.append(" and material_warehouse_id = \"" + request.getParameter("materialWarehouseId") + "\"");
        }
        //          封装审批状态查询条件
        if (StringUtil.isNotEmpty(request.getParameter("materialApprove"))) {
            queryStr.append(" and material_approve = \"" + request.getParameter("materialApprove") + "\"");
        }
        //          封装休假期间查询条件
        if (StringUtil.isNotEmpty(request.getParameter("vacationDate_begin")) && StringUtil.isNotEmpty(request.getParameter("vacationDate_end"))) {
            queryStr.append(" and vacation_start_date >= \"" + request.getParameter("vacationDate_begin") + "\"");
            queryStr.append(" and vacation_end_date >= \"" + request.getParameter("vacationDate_end") + "\"");
        }
        //          封装请购日期查询条件
        if (StringUtil.isNotEmpty(request.getParameter("materialDate_begin")) && StringUtil.isNotEmpty(request.getParameter("materialDate_end"))) {
            queryStr.append(" and material_date between \"" + request.getParameter("materialDate_begin") + "\" and \"" + request.getParameter("materialDate_end") + "\" ");
        }
        if (StringUtil.isNotEmpty(request.getParameter("datagridType"))) {
            StringBuffer typeSqlStr = new StringBuffer();
            typeSqlStr.append("select tbm.* from t_b_material tbm RIGHT JOIN (select *,SUM(material_info_no_num) noSumNum from t_b_material_info where material_info_no_num > 0 GROUP BY material_id) tbmi on tbmi.material_id = tbm.id ");
            typeSqlStr.append(queryStr);
            Integer pageNumber = dataGrid.getPage();
            Integer pageSize = dataGrid.getRows();
            List<Map<String, Object>> totalDataList = this.systemService.findForJdbc(typeSqlStr.toString());
            typeSqlStr.append(" ORDER BY material_date DESC ");
            typeSqlStr.append(" LIMIT " + ((pageNumber - 1) * pageSize) + "," + pageSize);
            List<Map<String, Object>> dataList = this.systemService.findForJdbc(typeSqlStr.toString());
            List<Map<String, Object>> toolDataList = new ArrayList<>();
            //下划线转驼峰
            for (Map<String, Object> dataItem : dataList) {
                Map<String, Object> toolDataItem = new HashMap<>();
                for (String mapKey : dataItem.keySet()) {
                    toolDataItem.put(Tool.lineToHump(mapKey), dataItem.get(mapKey));
                }
                toolDataList.add(toolDataItem);
            }
            dataGrid.setTotal(totalDataList.size());
            dataGrid.setResults(toolDataList);
            TagUtil.datagrid(response, dataGrid);
        } else {
            List<Map<String, Object>> dataGridList = this.systemService.toDataGridByDataGrid(" (select tbm.* from t_b_material tbm RIGHT JOIN (select *,SUM(material_info_no_num) noSumNum from t_b_material_info where material_info_no_num > 0 GROUP BY material_id) tbmi on tbmi.material_id = tbm.id) ", "create_by", "request_id", "create_date", dataGrid, queryStr.toString());
            dataGrid.setResults(dataGridList);
            TagUtil.datagrid(response, dataGrid);
        }
    }

    /**
     * 生成当前经办人的审批权限集合
     *
     * @return
     * @author刘梦祥
     * @Date 2021年11月29日00:42:57
     */
    public String getUserRuleMap(String ruleType, String agentUserId) {
        TSBaseUser tsBaseUser = this.systemService.getEntity(TSBaseUser.class, agentUserId);
        if (tsBaseUser != null && tsBaseUser.getDepartid() != null) {
            Map<String, String> ruleMap = new HashMap<>();
            switch (ruleType) {
//                科室组长（组长）
                case "groupLeader":
                    ruleMap.put("departId", tsBaseUser.getDepartid());
                    ruleMap.put("inPostid", "ff8080817b760b5d017b805b3b3301de");
                    break;
//                安全保障科科长（科长）
                case "securitySectionChief":
                    ruleMap.put("departId", "ff8080817b5e7d81017b62bca59a0136");
                    ruleMap.put("inPostid", "ff8080817b760b5d017b8057b15901c6");
                    break;
//                人事科科科长（科长）
                case "personnelSectionChief":
                    ruleMap.put("departId", "ff8080817b5e7d81017b62bc58860132");
                    ruleMap.put("inPostid", "ff8080817b760b5d017b8057b15901c6");
                    break;
//                  科室科长（科长）
                case "sectionChief":
                    ruleMap.put("departId", tsBaseUser.getDepartid());
                    if("ff8080817b5e7d81017b62bc1cb4012e".equals(tsBaseUser.getDepartid())){
                        ruleMap.put("inPostid", "ff8080817b760b5d017b805789b201c4");
                    }else{
                        ruleMap.put("inPostid", "ff8080817b760b5d017b8057b15901c6");
                    }
                    break;
//                    分管领导（根据情况确定）
                case "inChargeOfTheLeadership":
//                  如果是人事科或者办公室科（高总）
                    if ("ff8080817b5e7d81017b62bc58860132".equals(tsBaseUser.getDepartid()) || "ff8080817b5e7d81017b62bc1cb4012e".equals(tsBaseUser.getDepartid()) || "ff8080817b760b5d017b76ef38ff0018".equals(tsBaseUser.getDepartid())) {
                        ruleMap.put("userId", "2c9e7297812325a7018141f5f9fb003b");
//                  仓库科、保洁科、市场部(周总)
                    } else if ("ff8080817b5e7d81017b62bcff99013c".equals(tsBaseUser.getDepartid()) || "ff8080817b5e7d81017b62bcc47a0138".equals(tsBaseUser.getDepartid()) || "ff8080817b5e7d81017b62bc74480134".equals(tsBaseUser.getDepartid())) {
                        ruleMap.put("userId", "2c9e7297812325a7018141e044cc0036");
//                  安全保障科、清运科（潘总）
                    } else if ("ff8080817b5e7d81017b62bca59a0136".equals(tsBaseUser.getDepartid()) || "ff8080817b5e7d81017b62bcea8c013a".equals(tsBaseUser.getDepartid())) {
                        ruleMap.put("userId", "2c9e7297812325a7018141f5fb120040");
                    }
//                    ruleMap.put("inPostid", "ff8080817b760b5d017b8054e09101b9");
                    break;
//                  总经理(田总)
                case "generalManager":
                    ruleMap.put("userId", "2c9e7297812325a7018141e043a30031");
//                    ruleMap.put("inPostid", "ff8080817b760b5d017b80547e1401b7");
                    break;
//                    指定用户（指定的用户id：userid:xxxxxxxxxxxx）
                default:
                    ruleMap.put("userId", ruleType.substring(7));
                    break;
            }
            return JSONObject.toJSONString(ruleMap);
        } else {
            return null;
        }
    }

    /**
     * 物料采购页面数据请求（只查询已通过且未到货的采购信息）
     *
     * @param tBMaterial
     * @param request
     * @param response
     * @param dataGrid
     * @author 刘梦祥
     * @Date 2021年11月17日16:15:53
     */
    @RequestMapping(params = {"materialPurchasingDatagrid"})
    public void materialPurchasingDatagrid(TBMaterialEntity tBMaterial, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        CriteriaQuery cq = new CriteriaQuery(TBMaterialEntity.class, dataGrid);
        HqlGenerateUtil.installHql(cq, tBMaterial, request.getParameterMap());
        cq.eq("materialApprove", "已通过");
        cq.add();
        this.tBMaterialService.getDataGridReturn(cq, true);
        List<TBMaterialEntity> list = dataGrid.getResults();
        //检查是否到货
        List<TBMaterialEntity> resList = new ArrayList<>();
        if (list != null && list.size() > 0) {
            for (TBMaterialEntity listItem : list) {
                //得到采购单id
                String id = listItem.getId();
                DataGrid dataGrid1 = new DataGrid();
                CriteriaQuery cq1 = new CriteriaQuery(TBMaterialArrivalEntity.class, dataGrid1);
                cq1.eq("materialId", id);
                cq1.add();
                this.tbMaterialArrivalService.getDataGridReturn(cq1, true);
                List<TBMaterialArrivalEntity> tbMaterialArrival = dataGrid1.getResults();
                if (tbMaterialArrival == null || tbMaterialArrival.size() == 0) {
                    resList.add(listItem);
                }
            }
        }
        dataGrid.setResults(resList);
        dataGrid.setTotal(resList.size());
        TagUtil.datagrid(response, dataGrid);
    }

    /**
     * 物料到货页面数据请求
     *
     * @param tbMaterialArrivalEntity
     * @param request
     * @param response
     * @param dataGrid
     * @author 刘梦祥
     * @Date 2021年11月18日14:28:35
     */
    @RequestMapping(params = {"materialArrivalDatagrid"})
    public void materialArrivalDatagrid(TBMaterialArrivalEntity tbMaterialArrivalEntity, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        CriteriaQuery cq = new CriteriaQuery(TBMaterialArrivalEntity.class, dataGrid);
        HqlGenerateUtil.installHql(cq, tbMaterialArrivalEntity, request.getParameterMap());
        cq.addOrder("createTime", SortDirection.desc);
        cq.add();
        this.tbMaterialArrivalService.getDataGridReturn(cq, true);
        List<TBMaterialArrivalEntity> list = dataGrid.getResults();
        dataGrid.setResults(list);
        dataGrid.setTotal(list.size());
        //审批权限查询end
        TagUtil.datagrid(response, dataGrid);
    }

    /**
     * 物料到货页面选择采购单
     *
     * @param request
     * @author 刘梦祥
     * @Date 2021年11月21日21:33:34
     */
    @RequestMapping(params = {"doAddArrival"})
    @ResponseBody
    public AjaxJson doAddArrival(HttpServletRequest request) {
        AjaxJson j = new AjaxJson();
        try {
            HttpSession session = ContextHolderUtils.getSession();
            TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
            //直接将货品信息中的请购科室信息和仓库信息写入到物料到货表中
            String materialId = request.getParameter("materialId");
            String materialDaptId = request.getParameter("materialDaptId");
            String materialWarehouseId = request.getParameter("materialWarehouseId");
            //物料到货表添加记录
            TBMaterialArrivalEntity tbM = new TBMaterialArrivalEntity();
            tbM.setId(UUID.randomUUID().toString());
            tbM.setMaterialId(materialId);
            tbM.setMaterialDaptId(materialDaptId);
            tbM.setMaterialWarehouseId(materialWarehouseId);
            tbM.setProcurementTime(new Date());
            tbM.setCreateTime(new Date());
            tbM.setReportStatus("0");
            tbM.setRemake("");
            tbM.setCreateUser(tuser.getId());
            this.tbMaterialArrivalService.save(tbM);
            String message = "添加成功";
            j.setMsg(message);
        } catch (Exception e) {
            j.setSuccess(false);
            j.setMsg("添加失败" + e.getMessage());
        }
        return j;
    }


    /**
     * 根据采购单id打开编辑页面
     *
     * @return void
     * @author 刘梦祥
     * @Date 2021年11月22日11:14:19
     */
    @RequestMapping(params = {"goUpdatePurchaseOrderPage"})
    @Transactional(rollbackFor = Exception.class)
    public ModelAndView goUpdatePurchaseOrderPage(TBMaterialArrivalEntity tbM, HttpServletRequest request) {
//      物料到货表id
        String id = request.getParameter("id");
//      根据到货表主键id获取到货信息
        tbM = this.systemService.getEntity(TBMaterialArrivalEntity.class, id);
        if (tbM != null) {
            String materialId = tbM.getMaterialId();
//          仓库信息
            String materialWarehouseId = tbM.getMaterialWarehouseId();
//          备注信息
            String remake = tbM.getRemake();
//          到货表id
            String ArrivalId = tbM.getId();
//          入库时间
            if (tbM.getPutTime() != null) {
                Date putTime = tbM.getPutTime();
                request.setAttribute("putTime", simpleDateFormat.format(putTime));
            }
            DataGrid dataGrid = new DataGrid();
            dataGrid.setRows(99999);
//          根据采购单id获取采购单详情列表
            CriteriaQuery cq = new CriteriaQuery(TBMaterialInfoEntity.class, dataGrid);
            cq.eq("materialId", materialId);
//            cq.gt("materialInfoNoNum", 0);
            cq.add();
            List<TBMaterialInfoEntity> tbMList = this.tBMaterialService.getListByCriteriaQuery(cq, true);
//          得到暂存的到货数量
            List<String> goodsId = JSONObject.parseObject(tbM.getGoodsIds(), ArrayList.class);
            List<String> goodsNums = JSONObject.parseObject(tbM.getGoodsNums(), ArrayList.class);
            //首先判断是否存在未到货数量
            for (TBMaterialInfoEntity item : tbMList) {
//              写入未到货数量
                if (item.getMaterialInfoNoNum() == null) {
                    item.setMaterialInfoNoNum(0);
                }
//              写入累计到货数量
                item.setCountGoodsNum(item.getMaterialInfoNum() - item.getMaterialInfoNoNum());
//              初始化本次到货数量以及未到货数量
                if (goodsId != null && goodsNums != null && goodsId.contains(item.getMaterialInfoGoodsId())) {
                    int goodsIndex = goodsId.indexOf(item.getMaterialInfoGoodsId());
                    item.setNowGoodsNum(Integer.parseInt(goodsNums.get(goodsIndex)));
                } else {
                    item.setNowGoodsNum(0);
                }
//              获取货品id并得到数据字典中的计量单位
                TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, item.getMaterialInfoGoodsId());
                if (tbGoodsInfoEntity.getBaseUnit() != null) {
//                根据货品的计量单位code到字典表中获取数据
                    TSType tsType = this.systemService.getType(tbGoodsInfoEntity.getBaseUnit(), "metering_calcu_unit");
                    item.setBaseUnit(tsType.getTypename());
                }
            }
//          add-刘梦祥-2021年12月15日17:18:15（根据最新需求，需要有删除操作。）(当到货表单已经初始化过goods_ids字段就会变成一个字符串)
            if (StringUtil.isNotEmpty(tbM.getGoodsIds())) {
                List<String> goodsIds = JSONObject.parseObject(tbM.getGoodsIds(), ArrayList.class);
                List<TBMaterialInfoEntity> newTbMList = new ArrayList<>();
                if (tbMList != null && tbMList.size() > 0) {
                    for (TBMaterialInfoEntity item : tbMList) {
                        if (goodsIds.contains(item.getMaterialInfoGoodsId())) {
                            newTbMList.add(item);
                        }
                    }
                }
                request.setAttribute("TBMaterialInfoEntity", newTbMList);
            } else {
                request.setAttribute("TBMaterialInfoEntity", tbMList);
            }
            String isView = request.getParameter("viewFlag");
            request.setAttribute("viewFlag", isView);
//          传参仓库信息
            WarehouseEntity warehouseEntity = this.systemService.getEntity(WarehouseEntity.class, materialWarehouseId);
            request.setAttribute("materialWarehouseId", warehouseEntity.getWarehouseName());
//          传参备注信息
            request.setAttribute("remake", remake);
            request.setAttribute("ArrivalId", ArrivalId);
            request.setAttribute("materialId", materialId);
            request.setAttribute("reportStatus", tbM.getReportStatus());
            if (StringUtil.isNotEmpty(request.getParameter("load"))) {
                request.setAttribute("load", request.getParameter("load"));
            }
        }
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/tBMaterialPurchaseOrder-update");
    }

    /**
     * 物料到货确认到货
     *
     * @return void
     * @author 刘梦祥
     * @Date 2021年12月14日15:25:18
     */
    @RequestMapping(params = {"reqortGoodsById"})
    @ResponseBody
    @Transactional(rollbackFor = Exception.class)
    public AjaxJson reqortGoodsById(TBMaterialArrivalEntity tbM, HttpServletRequest request) throws ParseException {
        AjaxJson j = new AjaxJson();
        try {
            HttpSession session = ContextHolderUtils.getSession();
            TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
            TBMaterialArrivalEntity tbMselect = this.systemService.getEntity(TBMaterialArrivalEntity.class, tbM.getId());
            if ("1".equals(tbMselect.getReportStatus())) {
//              其他用户已经操作到货
                j.setMsg("物料到货失败，已经有其他用户操作到货！请刷新后重试！");
                j.setSuccess(false);
                return j;
            }
            if (tbMselect != null && StringUtil.isNotEmpty(tbMselect.getGoodsIds()) && StringUtil.isNotEmpty(tbMselect.getGoodsNums()) && StringUtil.isNotEmpty(tbMselect.getMaterialId())) {
                tbMselect.setReportStatus("1");
                this.systemService.saveOrUpdate(tbMselect);
                List<String> goodsId = JSONObject.parseObject(tbMselect.getGoodsIds(), ArrayList.class);
                List<String> goodsNums = JSONObject.parseObject(tbMselect.getGoodsNums(), ArrayList.class);
                for (int i = 0; i < goodsId.size(); i++) {
                    DataGrid dataGrid = new DataGrid();
//                  采购单详情表
                    TBMaterialInfoEntity tbMaterialInfo = new TBMaterialInfoEntity();
                    tbMaterialInfo.setMaterialId(tbMselect.getMaterialId());
                    tbMaterialInfo.setMaterialInfoGoodsId(goodsId.get(i));
                    CriteriaQuery cq = new CriteriaQuery(TBMaterialInfoEntity.class, dataGrid);
                    HqlGenerateUtil.installHql(cq, tbMaterialInfo);
                    cq.add();
//                  查询采购单数据
                    List<TBMaterialInfoEntity> tbMList = this.tBMaterialService.getListByCriteriaQuery(cq, true);
                    if (tbMList.size() == 1) {
                        tbMList.get(0).setMaterialInfoNoNum(tbMList.get(0).getMaterialInfoNoNum() - Integer.parseInt(goodsNums.get(i)));
                        this.tBMaterialService.saveOrUpdate(tbMList.get(0));
                    }
//                  写入数据到现存量表
                    DataGrid dataGrid2 = new DataGrid();
//                  物料现存量表
                    TBMaterialStockOnHandEntity tbMaterialStockOnHand = new TBMaterialStockOnHandEntity();
                    tbMaterialStockOnHand.setGoodsId(goodsId.get(i));
                    CriteriaQuery cq2 = new CriteriaQuery(TBMaterialStockOnHandEntity.class, dataGrid2);
                    HqlGenerateUtil.installHql(cq2, tbMaterialStockOnHand);
                    cq2.add();
//                  查询采购单数据
                    List<TBMaterialStockOnHandEntity> tbMSOH = this.tbMaterialStockOnHandService.getListByCriteriaQuery(cq2, true);
//                  判断是否存在
                    if (tbMSOH.size() == 1) {
//                      已存在该采购单的货品
                        tbMSOH.get(0).setStockOnHand(tbMSOH.get(0).getStockOnHand() + Integer.parseInt(goodsNums.get(i)));
                        tbMSOH.get(0).setUpdateTime(new Date());
                        tbMSOH.get(0).setLastPutTime(tbMselect.getPutTime());
                        tbMSOH.get(0).setUpdateUser(tuser.getId());
                        this.tbMaterialStockOnHandService.saveOrUpdate(tbMSOH.get(0));
                    } else {
//                      不存在就新增
                        TBMaterialStockOnHandEntity tbMaterialStockOnHandEntity = new TBMaterialStockOnHandEntity();
                        tbMaterialStockOnHandEntity.setId(UUID.randomUUID().toString());
                        tbMaterialStockOnHandEntity.setGoodsId(goodsId.get(i));
                        tbMaterialStockOnHandEntity.setMaterialDaptId(tbMselect.getMaterialDaptId());
                        tbMaterialStockOnHandEntity.setMaterialWarehouseId(tbMselect.getMaterialWarehouseId());
                        tbMaterialStockOnHandEntity.setStockOnHand(Integer.parseInt(goodsNums.get(i)));
                        tbMaterialStockOnHandEntity.setLastPutTime(tbMselect.getPutTime());
                        tbMaterialStockOnHandEntity.setCreateUser(tuser.getId());
                        tbMaterialStockOnHandEntity.setCreateTime(new Date());
                        this.tbMaterialStockOnHandService.save(tbMaterialStockOnHandEntity);
                    }
                }
            } else {
//              未编辑到货信息
                j.setMsg("物料到货失败，未编辑到货信息！请编辑后重试！");
                j.setSuccess(false);
                return j;
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(e.getMessage());
        }
        return j;
    }

    /**
     * 物料确认出货
     *
     * @return void
     * @author 刘梦祥
     * @Date 2021年12月14日20:24:49
     */
    @RequestMapping(params = {"reqortOutGoodsById"})
    @ResponseBody
    @Transactional(rollbackFor = Exception.class)
    public AjaxJson reqortOutGoodsById(TBMaterialDeliveryEntity tbMd, HttpServletRequest request) throws ParseException {
        AjaxJson j = new AjaxJson();
        try {
            boolean codeStatus = true;
            TBMaterialDeliveryEntity tbMselect = this.systemService.getEntity(TBMaterialDeliveryEntity.class, tbMd.getId());
            if ("1".equals(tbMselect.getReportStatus())) {
                j.setMsg("物料出货失败，已经有其他用户操作出货！请刷新后重试！");
                j.setSuccess(false);
                return j;
            }
            HttpSession session = ContextHolderUtils.getSession();
            TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
//          得到到货日志表中对应的详细数据
            DataGrid dataGrid1 = new DataGrid();
            dataGrid1.setRows(99999);
            CriteriaQuery criteriaQuery = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrid1);
            criteriaQuery.eq("deliveryId", tbMd.getId());
            criteriaQuery.add();
            List<TBMaterialDeliveryInfoEntity> tbMInfoselect = this.systemService.getListByCriteriaQuery(criteriaQuery, true);
            HashSet<String> goodsList = new HashSet<>();
            if (tbMInfoselect != null && tbMInfoselect.size() > 0) {
                for (TBMaterialDeliveryInfoEntity item : tbMInfoselect) {
                    if (StringUtil.isNotEmpty(item.getReceiverCarId()) && StringUtil.isNotEmpty(item.getGoodsId())) {
                        goodsList.add(item.getGoodsId());
                    } else {
                        codeStatus = false;
                        if (StringUtil.isEmpty(item.getReceiverCarId())) {
                            j.setMsg("物料出货失败，出货详情领料车信息异常！请检查后重试！");
                        } else {
                            j.setMsg("物料出货失败，出货详情货品信息异常！请检查后重试！");
                        }
                        j.setSuccess(false);
                        return j;
                    }
                }
            }
//          根据货品id，仓库id，和领料科室id查询现存量数据(修改现存量的数据)
            DataGrid dataGrid = new DataGrid();
            CriteriaQuery cq = new CriteriaQuery(TBMaterialStockOnHandEntity.class, dataGrid);
//          封裝仓库id查询条件
            cq.eq("materialWarehouseId", tbMselect.getMaterialWarehouseId());
//          封装请购科室id查询条件
            cq.eq("materialDaptId", tbMselect.getMaterialDaptId());
//          封装货品id
            cq.in("goodsId", goodsList.toArray());
            cq.add();
            this.tbMaterialStockOnHandService.getDataGridReturn(cq, true);
//          查询得到所有的现存量数据
            List<TBMaterialStockOnHandEntity> list = dataGrid.getResults();
//          修改物料现存量
            if (list != null && tbMInfoselect != null && tbMInfoselect.size() > 0) {
                // 首先遍历现存量数据
                for (TBMaterialStockOnHandEntity item : list) {
//                    其次遍历出货详细数据
                    for (TBMaterialDeliveryInfoEntity infoItem : tbMInfoselect) {
//                        如果现存量数据中的货品id等于出货详细数据
                        if (item.getGoodsId().equals(infoItem.getGoodsId())) {
//                            那么就更新现存量数据
                            if (item.getStockOnHand() - infoItem.getOutNum() < 0) {
//                              抛出异常
                                codeStatus = false;
                                throw new Exception("物料出货失败,物料现存量不足！请检查后重试！");
                            } else {
                                item.setStockOnHand(item.getStockOnHand() - infoItem.getOutNum());
//                              更新最新出货时间
                                item.setLastOutTime(tbMselect.getOutTime());
                            }
                        }
                    }
                }
                for (TBMaterialStockOnHandEntity item : list) {
//                  执行更新
                    this.tbMaterialStockOnHandService.saveOrUpdate(item);
                }
                if (codeStatus) {
                    j.setMsg("确认出货成功");
                    tbMselect.setReportStatus("1");
                    tbMselect.setUpdateUser(tuser.getId());
                    tbMselect.setUpdateTime(new Date());
                    this.systemService.saveOrUpdate(tbMselect);
                } else {
                    j.setSuccess(false);
                    j.setMsg("物料出货失败,物料现存量不足！");
                    return j;
                }
            } else {
                j.setSuccess(false);
                j.setMsg("现存量数据查询异常");
                throw new Exception("物料出货失败,现存量数据查询异常！请检查后重试！");
            }
        } catch (Exception e) {
            e.printStackTrace();
            j.setSuccess(false);
            j.setMsg(e.getMessage());
            return j;
        }
        return j;
    }

    /**
     * 修改物料到货信息
     *
     * @return void
     * @author 刘梦祥
     * @Date 2021年11月22日14:58:47
     */
    @RequestMapping(params = {"doUpdatePurchaseOrderPage"})
    @ResponseBody
    @Transactional(rollbackFor = Exception.class)
    public AjaxJson doUpdatePurchaseOrderPage(TBMaterialArrivalEntity tbM, HttpServletRequest request) throws ParseException {
        AjaxJson j = new AjaxJson();
        try {
            HttpSession session = ContextHolderUtils.getSession();
            TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
//          采购单id
            String materialId = request.getParameter("materialId");
//          获取到货表id
            String arrivalId = request.getParameter("ArrivalId");
//          获取到货时间
            String putTime = request.getParameter("putTime");
            if (putTime.length() == 10) {
                putTime += " 00:00:00";
            }
//          获取到货备注
            String ArrivalIdRemake = request.getParameter("ArrivalIdRemake");
            String message = "修改成功";
            j.setMsg(message);
//          写入数据到到货表
            TBMaterialArrivalEntity tbMselect = this.systemService.getEntity(TBMaterialArrivalEntity.class, arrivalId);
            if ("1".equals(tbMselect.getReportStatus())) {
                j.setSuccess(false);
                j.setMsg("表单已被提交，请刷新后重试！");
                return j;
            } else {
//          获取采购单关联货品id
                Map<String, String[]> parameterMap = request.getParameterMap();
                String[] goodsId = parameterMap.get("materialInfoGoodsId");
//          获取当次到货数量
                String[] goodsNums = parameterMap.get("nowGoodsNum");
                tbMselect.setRemake(ArrivalIdRemake);
                Date date = simpleDateFormat.parse(putTime);
                tbMselect.setMaterialId(materialId);
                tbMselect.setPutTime(date);
                tbMselect.setReportStatus("0");
                tbMselect.setUpdateUser(tuser.getId());
                tbMselect.setUpdateTime(new Date());
                tbMselect.setGoodsIds(JSONObject.toJSONString(goodsId));
                tbMselect.setGoodsNums(JSONObject.toJSONString(goodsNums));
                this.tbMaterialArrivalService.saveOrUpdate(tbMselect);
                return j;
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(e.getMessage());
        }
    }

    /**
     * 添加或修改物料出货信息
     *
     * @return void
     * @author 刘梦祥
     * @Date 2021年11月24日10:27:00
     */
    @RequestMapping(params = {"doUpdateDelivery"})
    @ResponseBody
    @Transactional(rollbackFor = Exception.class)
    public AjaxJson doUpdateDelivery(TBMaterialDeliveryEntity tbmd, HttpServletRequest request) throws ParseException {
        AjaxJson j = new AjaxJson();
        try {
            HttpSession session = ContextHolderUtils.getSession();
            TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
//          检查是否存在出货id
            String TBNDId = tbmd.getId();
//          获取操作人id
            String createOrUpdateUserId = tuser.getId();
//          获取出货时间
            String outTime = request.getParameter("outTime");
            if (outTime.length() == 10) {
                outTime += " 00:00:00";
            }
            tbmd.setOutTime(simpleDateFormat.parse(outTime));
//          获取操作时间
            Date createOrUpdateTime = new Date();
//          如果存在出货详情表id（即为编辑操作）
            if (StringUtil.isNotEmpty(TBNDId)) {
//              首先根据出货id获取出货信息
                TBMaterialDeliveryEntity tbMaterialDelivery = this.systemService.getEntity(TBMaterialDeliveryEntity.class, TBNDId);
                tbMaterialDelivery.setUpdateUser(createOrUpdateUserId);
                tbMaterialDelivery.setUpdateTime(createOrUpdateTime);
                tbMaterialDelivery.setRemake(tbmd.getRemake());
                tbMaterialDelivery.setOutTime(tbmd.getOutTime());
//              更新物料出货表数据
                this.tbMaterialDeliveryService.saveOrUpdate(tbMaterialDelivery);
//              首先根据出货id获取出货详情信息
                DataGrid dataGrid = new DataGrid();
                dataGrid.setRows(99999);
                CriteriaQuery cq = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrid);
//              封裝出货id查询条件
                cq.eq("deliveryId", TBNDId);
                cq.add();
                this.tbMaterialDeliveryInfoService.getDataGridReturn(cq, true);
//              查询得到所有的现存量数据
                List<TBMaterialDeliveryInfoEntity> list = dataGrid.getResults();
                Map<String, String[]> requestMap = request.getParameterMap();
                if (requestMap.containsKey("infoId")) {
//                  得到form表单详细的物料出货详细日志id列表
                    String[] infoIds = requestMap.get("infoId");
//                  先执行删除操作
                    for (TBMaterialDeliveryInfoEntity tbIteminfo : list) {
//                    如果前端返回的form表单中的物料出货日志id不存在数据库中的物料出货的id，就执行删除操作
                        if (!Arrays.toString(infoIds).contains(tbIteminfo.getId())) {
                            this.systemService.deleteEntityById(TBMaterialDeliveryInfoEntity.class, tbIteminfo.getId());
                        }
                    }
//                  执行新增或者更新操作
                    for (int i = 0; i < infoIds.length; i++) {
                        TBMaterialDeliveryInfoEntity tbMaterialDeliveryInfo = new TBMaterialDeliveryInfoEntity();
                        String infoid = infoIds[i];
                        String deliveryId = TBNDId;
                        String goodsId = requestMap.get("goodsId")[i];
                        String receiverCarId = requestMap.get("receiverCarId")[i];
                        Integer outNum = Integer.parseInt(requestMap.get("outNum")[i]);
                        String remake = requestMap.get("materialInfoRemarks")[i];
                        if ("".equals(infoid)) {
//                          新增操作
                            tbMaterialDeliveryInfo.setId(UUID.randomUUID().toString());
                            tbMaterialDeliveryInfo.setDeliveryId(deliveryId);
                            tbMaterialDeliveryInfo.setCreateUser(createOrUpdateUserId);
                            tbMaterialDeliveryInfo.setCreateTime(createOrUpdateTime);
                            tbMaterialDeliveryInfo.setGoodsId(goodsId);
                            tbMaterialDeliveryInfo.setReceiverCarId(receiverCarId);
                            tbMaterialDeliveryInfo.setOutNum(outNum);
                            tbMaterialDeliveryInfo.setRemake(remake);
                        } else {
                            tbMaterialDeliveryInfo = this.systemService.getEntity(TBMaterialDeliveryInfoEntity.class, infoid);
                            tbMaterialDeliveryInfo.setGoodsId(goodsId);
                            tbMaterialDeliveryInfo.setDeliveryId(deliveryId);
                            tbMaterialDeliveryInfo.setReceiverCarId(receiverCarId);
                            tbMaterialDeliveryInfo.setOutNum(outNum);
                            tbMaterialDeliveryInfo.setRemake(remake);
//                          编辑操作
                            tbMaterialDeliveryInfo.setUpdateUser(createOrUpdateUserId);
                            tbMaterialDeliveryInfo.setUpdateTime(createOrUpdateTime);
                        }
                        this.tbMaterialDeliveryInfoService.saveOrUpdate(tbMaterialDeliveryInfo);
                        j.setSuccess(true);
                        j.setMsg("物料出货编辑成功！");
                    }
                }
            } else {
//              如果不存在出货详情表id（即为新增录入操作）
                String deliveryId = UUID.randomUUID().toString();
                tbmd.setId(deliveryId);
                tbmd.setCreateUser(createOrUpdateUserId);
                tbmd.setCreateTime(createOrUpdateTime);
                tbmd.setReportStatus("0");
                this.tbMaterialDeliveryService.save(tbmd);
//              新建出货详情日志
                Map<String, String[]> requestMap = request.getParameterMap();
                if (requestMap.containsKey("infoId")) {
//                  得到form表单详细的物料出货详细日志id列表
                    String[] infoIds = requestMap.get("infoId");
//                  执行新增或者更新操作
                    for (int i = 0; i < infoIds.length; i++) {
                        TBMaterialDeliveryInfoEntity tbMaterialDeliveryInfo = new TBMaterialDeliveryInfoEntity();
                        String goodsId = requestMap.get("goodsId")[i];
                        String receiverCarId = requestMap.get("receiverCarId")[i];
                        Integer outNum = Integer.parseInt(requestMap.get("outNum")[i]);
                        String remake = requestMap.get("materialInfoRemarks")[i];
//                          新增操作
                        tbMaterialDeliveryInfo.setId(UUID.randomUUID().toString());
                        tbMaterialDeliveryInfo.setCreateUser(createOrUpdateUserId);
                        tbMaterialDeliveryInfo.setCreateTime(createOrUpdateTime);
                        tbMaterialDeliveryInfo.setGoodsId(goodsId);
                        tbMaterialDeliveryInfo.setReceiverCarId(receiverCarId);
                        tbMaterialDeliveryInfo.setDeliveryId(deliveryId);
                        tbMaterialDeliveryInfo.setOutNum(outNum);
                        tbMaterialDeliveryInfo.setRemake(remake);
                        this.tbMaterialDeliveryInfoService.saveOrUpdate(tbMaterialDeliveryInfo);
                    }
                }
                j.setSuccess(true);
                j.setMsg("物料出货录入成功！");
            }
            return j;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(e.getMessage());
        }
    }

    /**
     * 物料到货页面选择采购单
     *
     * @param request
     * @author 刘梦祥
     * @Date 2021年11月21日21:33:34
     */
    @RequestMapping(params = {"doUpdateArrival"})
    @Transactional(rollbackFor = Exception.class)
    public AjaxJson doUpdateArrival(TBMaterialArrivalEntity tbM, HttpServletRequest request) {
        HttpSession session = ContextHolderUtils.getSession();
        TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
        //物料到货表添加修改记录
        tbM.setProcurementTime(new Date());
        tbM.setReportStatus("1");
        tbM.setUpdateUser(tuser.getId());
        //现存量表数据根据货品采购单id和货品写入或修改现存量（物料现存量的物品总量需要统计所有货品的现存量）
        AjaxJson j = new AjaxJson();
        try {
            this.tbMaterialArrivalService.saveOrUpdate(tbM);
            String message = "修改成功";
            j.setMsg(message);
            return j;
        } catch (Exception e) {
            e.printStackTrace();
            throw new BusinessException(e.getMessage());
        }
    }

    @RequestMapping(params = {"goAddPurchaseOrderPage"})
    public ModelAndView goAddPurchaseOrderPage(HttpServletRequest request) {
        if (StringUtil.isNotEmpty(request.getParameter("datagridType"))) {
            request.setAttribute("datagridType", request.getParameter("datagridType"));
        }
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/tBMaterialPurchaseOrder-add");
    }

    /**
     * 物料出货页面数据请求
     *
     * @param tbMaterialDeliveryEntity
     * @param request
     * @param response
     * @param dataGrid
     * @author 刘梦祥
     * @Date 2021年11月23日17:10:34
     */
    @RequestMapping(params = {"materialDeliveryDatagrid"})
    public void materialDeliveryDatagrid(TBMaterialDeliveryEntity tbMaterialDeliveryEntity, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        CriteriaQuery cq = new CriteriaQuery(TBMaterialDeliveryEntity.class, dataGrid);
        HqlGenerateUtil.installHql(cq, tbMaterialDeliveryEntity, request.getParameterMap());
        cq.add();
        this.tbMaterialDeliveryService.getDataGridReturn(cq, true);
        List<TBMaterialEntity> list = dataGrid.getResults();
        dataGrid.setResults(list);
        TagUtil.datagrid(response, dataGrid);
    }

    /**
     * 打开所有的物料现存量数据页面
     *
     * @author 刘梦祥
     * @Date 2021年11月23日17:10:30
     */
    @RequestMapping(params = {"goAddDelivery"})
    public ModelAndView goAddDelivery() {
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialDeliveryOpenSOHL-window");
    }

    /**
     * 根据指定的货品id，仓库id，请购科室id打开物料出货编辑页面
     *
     * @param request
     * @param dataGrid
     * @author 刘梦祥
     * @Date 2021年11月23日21:19:14
     */
    @RequestMapping(params = {"goAddDeliveryInfo"})
    public ModelAndView goAddDeliveryInfo(HttpServletRequest request, DataGrid dataGrid) throws ParseException {
//      获取页面类型
        String viewFlag = request.getParameter("viewFlag");
//      获取货品id
        String goodsId = request.getParameter("goodsId");
//      获取请购科室id
        String materialDaptId = request.getParameter("materialDaptId");
//      获取仓库id
        String materialWarehouseId = request.getParameter("materialWarehouseId");
        CriteriaQuery cq = new CriteriaQuery(TBMaterialStockOnHandEntity.class, dataGrid);
//       封裝仓库id查询条件
        if (materialWarehouseId != null && !"".equals(materialWarehouseId)) {
            cq.eq("materialWarehouseId", materialWarehouseId);
        }
//        封装请购科室id查询条件
        if (materialDaptId != null && !"".equals(materialDaptId)) {
            cq.eq("materialDaptId", materialDaptId);
        }
//        封装货品id
        if (goodsId != null && !"".equals(goodsId)) {
            cq.eq("goodsId", goodsId);
        }
        cq.add();
        this.tbMaterialStockOnHandService.getDataGridReturn(cq, true);
//      查询得到所有的现存量数据
        List<TBMaterialStockOnHandEntity> list = dataGrid.getResults();
        List<TBMaterialStockOnHandEntity> resList = new ArrayList<>();
//      将货品id一样的现存量数据现存量累加<货品id，累计现存量>
        Map<String, Map<String, Object>> resMap = new HashMap<>();
        if (list.size() > 0) {
            for (TBMaterialStockOnHandEntity tbmSOHItem : list) {
                String mapKeys = tbmSOHItem.getGoodsId() + "," + tbmSOHItem.getMaterialDaptId() + "," + tbmSOHItem.getMaterialWarehouseId();
                Map<String, Object> objectMap = new HashMap<>();
                objectMap.put("soh", tbmSOHItem.getStockOnHand());
                objectMap.put("putTime", tbmSOHItem.getLastPutTime());
                objectMap.put("outTime", tbmSOHItem.getLastOutTime());
                objectMap.put("materialDaptId", tbmSOHItem.getMaterialDaptId());
                objectMap.put("materialWarehouseId", tbmSOHItem.getMaterialWarehouseId());
                if (resMap.containsKey(mapKeys)) {
//                  存在该货品id
                    objectMap.put("soh", Integer.parseInt(String.valueOf(resMap.get(mapKeys).get("soh"))) + tbmSOHItem.getStockOnHand());
//                    如果入库时间<存在的入库时间就更新一下这个入库时间（取小值）
                    if (tbmSOHItem.getLastPutTime() != null) {
                        if (tbmSOHItem.getLastPutTime().compareTo(simpleDateFormat.parse(String.valueOf(resMap.get(mapKeys).get("putTime")))) < 0) {
                            objectMap.put("putTime", tbmSOHItem.getLastPutTime());
                        }
                    }
                    //                    如果出库时间>存在的出库时间就更新一下这个出库时间（取大值）
                    if (tbmSOHItem.getLastOutTime() != null && resMap.get(mapKeys).get("outTime") != null) {
                        if (tbmSOHItem.getLastOutTime().compareTo(simpleDateFormat.parse(String.valueOf(resMap.get(mapKeys).get("outTime")))) > 0) {
                            objectMap.put("outTime", tbmSOHItem.getLastOutTime());
                        }
                    } else {
                        objectMap.put("outTime", null);
                    }
                }
//                更新resMap对象
                resMap.put(mapKeys, objectMap);
            }
        }
        String returnPutTime = null;
        if (resMap.size() > 0) {
            for (String mapKeys : resMap.keySet()) {
//               首先根据货品id获取到一个大集合
                Map<String, Object> objectMap = resMap.get(mapKeys);
                String[] kesList = mapKeys.split(",");
                String goodsid = kesList[0];
//                根据货品id查询得到该货品的详细信息
                TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, goodsid);
//                创建返回实体
                TBMaterialStockOnHandEntity resTbmItem = new TBMaterialStockOnHandEntity();
                resTbmItem.setGoodsId(goodsid);
                resTbmItem.setMaterialDaptId(String.valueOf(objectMap.get("materialDaptId")));
                resTbmItem.setMaterialWarehouseId(String.valueOf(objectMap.get("materialWarehouseId")));
                resTbmItem.setStockOnHand(Integer.parseInt(String.valueOf(objectMap.get("soh"))));
                returnPutTime = String.valueOf(objectMap.get("putTime"));
                resTbmItem.setLastPutTime(objectMap.get("putTime") != null ? simpleDateFormat.parse(String.valueOf(objectMap.get("putTime"))) : null);
                resTbmItem.setLastOutTime(objectMap.get("outTime") != null ? simpleDateFormat.parse(String.valueOf(objectMap.get("outTime"))) : null);
                resTbmItem.setGoodsName(tbGoodsInfoEntity.getGoodsName());
                resTbmItem.setSpecification(tbGoodsInfoEntity.getSpecification());
                resTbmItem.setBaseUnit(tbGoodsInfoEntity.getBaseUnit());
                resTbmItem.setSalesUnit(tbGoodsInfoEntity.getSalesUnit());
//                整理的数据写入返回实体集合
                resList.add(resTbmItem);
            }
        }
        if (materialWarehouseId != null) {
            WarehouseEntity warehouseEntity = this.systemService.getEntity(WarehouseEntity.class, materialWarehouseId);
            request.setAttribute("materialWarehouseName", warehouseEntity.getWarehouseName());
        }
//      添加返回仓库名称
        request.setAttribute("materialWarehouseId", materialWarehouseId);
        request.setAttribute("TBMaterialStockOnHandList", resList);
        request.setAttribute("viewFlag", viewFlag);
        request.setAttribute("putTime", returnPutTime);
        request.setAttribute("materialDaptId", materialDaptId);
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialDelivery-update");
    }

    /**
     * 根据指定的货品id，仓库id，请购科室id打开物料出货编辑页面
     *
     * @param request
     * @author 刘梦祥
     * @Date 2021年11月24日15:20:35
     */
    @RequestMapping(params = {"goUpdateDelivery"})
    public ModelAndView goUpdateDelivery(HttpServletRequest request) throws ParseException {
//      获取页面类型
        String viewFlag = request.getParameter("viewFlag");
//      获取出货id
        String deliveryId = request.getParameter("id");
//      根据出货id获取出货信息
        TBMaterialDeliveryEntity tbMaterialDelivery = this.tbMaterialDeliveryService.getEntity(TBMaterialDeliveryEntity.class, deliveryId);
        if (tbMaterialDelivery != null) {
//          获取请购科室id
            String materialDaptId = tbMaterialDelivery.getMaterialDaptId();
//          获取仓库id
            String materialWarehouseId = tbMaterialDelivery.getMaterialWarehouseId();
//          查询出货日志详细信息
            DataGrid dataGrids = new DataGrid();
            CriteriaQuery cqs = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrids);
//          封裝仓库id查询条件
            cqs.eq("deliveryId", deliveryId);
            cqs.add();
            this.tbMaterialDeliveryInfoService.getDataGridReturn(cqs, true);
//          得到详细出货日志信息
            List<TBMaterialDeliveryInfoEntity> lists = dataGrids.getResults();
//          根据货品id,仓库id，请购科室id查询数据
            if (lists != null) {
//                  统计现存量结束
                String returnPutTime = null;
                String returnOutTime = null;
                List<TBMaterialStockOnHandEntity> resList = new ArrayList<>();
                for (TBMaterialDeliveryInfoEntity tbmdinfo : lists) {
                    String goodsId = tbmdinfo.getGoodsId();
                    DataGrid dataGrid = new DataGrid();
                    CriteriaQuery cq = new CriteriaQuery(TBMaterialStockOnHandEntity.class, dataGrid);
//                  封裝仓库id查询条件
                    if (materialWarehouseId != null && !"".equals(materialWarehouseId)) {
                        cq.eq("materialWarehouseId", materialWarehouseId);
                    }
//                  封装请购科室id查询条件
                    if (materialDaptId != null && !"".equals(materialDaptId)) {
                        cq.eq("materialDaptId", materialDaptId);
                    }
//                  封装货品id
                    if (goodsId != null && !"".equals(goodsId)) {
                        cq.eq("goodsId", goodsId);
                    }
                    cq.add();
                    this.tbMaterialStockOnHandService.getDataGridReturn(cq, true);
//                  查询得到所有的现存量数据
                    List<TBMaterialStockOnHandEntity> list = dataGrid.getResults();
//                  将货品id一样的现存量数据现存量累加<货品id，累计现存量>
                    Map<String, Map<String, Object>> resMap = new HashMap<>();
                    if (list.size() > 0) {
                        for (TBMaterialStockOnHandEntity tbmSOHItem : list) {
                            String mapKeys = tbmSOHItem.getGoodsId() + "," + tbmSOHItem.getMaterialDaptId() + "," + tbmSOHItem.getMaterialWarehouseId();
                            Map<String, Object> objectMap = new HashMap<>();
                            objectMap.put("soh", tbmSOHItem.getStockOnHand());
                            objectMap.put("putTime", tbmSOHItem.getLastPutTime());
                            objectMap.put("outTime", tbmSOHItem.getLastOutTime());
                            objectMap.put("materialDaptId", tbmSOHItem.getMaterialDaptId());
                            objectMap.put("materialWarehouseId", tbmSOHItem.getMaterialWarehouseId());
                            if (resMap.containsKey(mapKeys)) {
//                              存在该货品id
                                objectMap.put("soh", Integer.parseInt(String.valueOf(resMap.get(mapKeys).get("soh"))) + tbmSOHItem.getStockOnHand());
//                              如果入库时间<存在的入库时间就更新一下这个入库时间（取大值）
                                if (tbmSOHItem.getLastPutTime() != null) {
                                    if (tbmSOHItem.getLastPutTime().compareTo(simpleDateFormat.parse(String.valueOf(resMap.get(mapKeys).get("putTime")))) > 0) {
                                        objectMap.put("putTime", tbmSOHItem.getLastPutTime());
                                    }
                                }
//                              如果出库时间>存在的出库时间就更新一下这个出库时间（取大值）
                                if (tbmSOHItem.getLastOutTime() != null && resMap.get(mapKeys).get("outTime") != null) {
                                    if (tbmSOHItem.getLastOutTime().compareTo(simpleDateFormat.parse(String.valueOf(resMap.get(mapKeys).get("outTime")))) > 0) {
                                        objectMap.put("outTime", tbmSOHItem.getLastOutTime());
                                    }
                                } else {
                                    objectMap.put("outTime", null);
                                }
                            }
//                          更新resMap对象
                            resMap.put(mapKeys, objectMap);
                        }
                    }
                    if (resMap.size() > 0) {
                        for (String mapKeys : resMap.keySet()) {
//                          首先根据货品id获取到一个大集合
                            Map<String, Object> objectMap = resMap.get(mapKeys);
                            String[] kesList = mapKeys.split(",");
                            String goodsid = kesList[0];
//                          根据货品id查询得到该货品的详细信息
                            TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, goodsid);
//                          创建返回实体
                            TBMaterialStockOnHandEntity resTbmItem = new TBMaterialStockOnHandEntity();
//                          写入出货详细数据
                            resTbmItem.setId(tbmdinfo.getId());
                            resTbmItem.setReceiverCarId(tbmdinfo.getReceiverCarId());
                            if (tbmdinfo.getReceiverCarId() != null) {
                                CarEntity tbCar = this.systemService.getEntity(CarEntity.class, tbmdinfo.getReceiverCarId());
                                if(tbCar != null){
                                    resTbmItem.setReceiverCarName(tbCar.getPlate());
                                }else{
                                    resTbmItem.setReceiverCarName("");
                                }
                            }
                            resTbmItem.setOutNum(tbmdinfo.getOutNum());
                            resTbmItem.setMaterialInfoRemarks(tbmdinfo.getRemake());
//                          写入货品信息
                            resTbmItem.setGoodsId(goodsid);
                            resTbmItem.setMaterialDaptId(String.valueOf(objectMap.get("materialDaptId") == null ? null : objectMap.get("materialDaptId")));
                            resTbmItem.setMaterialWarehouseId(String.valueOf(objectMap.get("materialWarehouseId") == null ? null : objectMap.get("materialWarehouseId")));
                            resTbmItem.setStockOnHand(Integer.parseInt(String.valueOf(objectMap.get("soh") == null ? null : objectMap.get("soh") )));
                            returnPutTime = String.valueOf(objectMap.get("putTime") == null ? "" : objectMap.get("putTime"));
                            if(tbMaterialDelivery.getOutTime() != null){
                                returnOutTime = simpleDateFormat.format(tbMaterialDelivery.getOutTime());
                            }
                            if(tbMaterialDelivery.getOutTime() != null){
                                resTbmItem.setLastOutTime(tbMaterialDelivery.getOutTime());
                            }
                            resTbmItem.setGoodsName(tbGoodsInfoEntity.getGoodsName());
                            resTbmItem.setSpecification(tbGoodsInfoEntity.getSpecification());
                            resTbmItem.setBaseUnit(tbGoodsInfoEntity.getBaseUnit());
                            resTbmItem.setSalesUnit(tbGoodsInfoEntity.getSalesUnit());
//                          整理的数据写入返回实体集合
                            resList.add(resTbmItem);
                        }
                    }
                    if (materialWarehouseId != null) {
                        WarehouseEntity warehouseEntity = this.systemService.getEntity(WarehouseEntity.class, materialWarehouseId);
                        request.setAttribute("materialWarehouseName", warehouseEntity.getWarehouseName());
                    }
                }
//              添加返回仓库名称
                request.setAttribute("materialWarehouseId", materialWarehouseId);
                request.setAttribute("TBMaterialStockOnHandList", resList);
                request.setAttribute("viewFlag", viewFlag);
                request.setAttribute("putTime", returnPutTime);
                request.setAttribute("materialDaptId", materialDaptId);
                request.setAttribute("remake", tbMaterialDelivery.getRemake());
//              返回主要信息(出货日志id、出库时间)
                request.setAttribute("id", deliveryId);
                request.setAttribute("outTime", returnOutTime);
            }
            return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialDelivery-update");
        } else {
            return null;
        }
    }

    /**
     * 根据指定的出货id打开物料出货编辑页面
     *
     * @param request
     * @author 刘梦祥
     * @Date 2021年11月24日13:41:26
     */
    @RequestMapping(params = {"goUpdateDeliveryInfo"})
    public ModelAndView goUpdateDeliveryInfo(HttpServletRequest request) throws ParseException {
//      获取页面类型
        String viewFlag = request.getParameter("viewFlag");
        String id = request.getParameter("id");
//      根据id获取物料出货信息
        TBMaterialDeliveryEntity tbMaterialDeliveryEntity = this.tbMaterialDeliveryService.getEntity(TBMaterialDeliveryEntity.class, id);
        if (tbMaterialDeliveryEntity != null) {
//      根据物料出货id查询物料出货详情信息
            DataGrid dataGrid = new DataGrid();
            CriteriaQuery cq = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrid);
        }
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialDelivery-update");
    }

    /**
     * 物料现存量页面数据请求
     *
     * @param tbMaterialStockOnHandEntity
     * @param request
     * @param response
     * @param dataGrid
     * @author 刘梦祥
     * @Date 2021年11月18日14:29:44
     */
    @RequestMapping(params = {"materialStockOnHandDatagrid"})
    public void materialStockOnHandDatagrid(TBMaterialStockOnHandEntity tbMaterialStockOnHandEntity, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) throws ParseException {
//        根据货品名称进行模糊查询得到货品id
        List<TBGoodsInfoEntity> tbGoodsInfoEntityList = new ArrayList<>();
        boolean goodsNameQueryState = false;
        if (tbMaterialStockOnHandEntity.getGoodsName() != null && !"".equals(tbMaterialStockOnHandEntity.getGoodsName())) {
            goodsNameQueryState = true;
            DataGrid dataGridGoods = new DataGrid();
            dataGridGoods.setRows(99999);
            CriteriaQuery cqgoods = new CriteriaQuery(TBGoodsInfoEntity.class, dataGridGoods);
            cqgoods.like("goodsName", "%" + tbMaterialStockOnHandEntity.getGoodsName() + "%");
            cqgoods.add();
            tbGoodsInfoEntityList = this.tBGoodsInfoService.getListByCriteriaQuery(cqgoods, true);
        }
        CriteriaQuery cq = new CriteriaQuery(TBMaterialStockOnHandEntity.class, dataGrid);
//       封裝仓库id查询条件
        if (tbMaterialStockOnHandEntity.getMaterialWarehouseId() != null && !"".equals(tbMaterialStockOnHandEntity.getMaterialWarehouseId())) {
            cq.eq("materialWarehouseId", tbMaterialStockOnHandEntity.getMaterialWarehouseId());
        }
//        封装请购科室id查询条件
        if (tbMaterialStockOnHandEntity.getMaterialDaptId() != null && !"".equals(tbMaterialStockOnHandEntity.getMaterialDaptId())) {
            cq.eq("materialDaptId", tbMaterialStockOnHandEntity.getMaterialDaptId());
        }
        List<TBMaterialStockOnHandEntity> list = new ArrayList<>();
        if (goodsNameQueryState) {
            if(tbGoodsInfoEntityList.size() > 0){
                List<String> list2 = new ArrayList<>();
                for (TBGoodsInfoEntity tbGoodsInfoEntityItem : tbGoodsInfoEntityList) {
                    list2.add(tbGoodsInfoEntityItem.getId());
                }
                String[] goodsId = list2.toArray(new String[list2.size()]);
                cq.in("goodsId", goodsId);
                cq.add();
                //      查询得到所有的现存量数据
                this.tbMaterialStockOnHandService.getDataGridReturn(cq, true);
                list = dataGrid.getResults();
            }
        }else{
            cq.add();
            //      查询得到所有的现存量数据
            this.tbMaterialStockOnHandService.getDataGridReturn(cq, true);
            list = dataGrid.getResults();
        }
        List<TBMaterialStockOnHandEntity> resList = new ArrayList<>();
//      将货品id一样的现存量数据现存量累加<货品id，累计现存量>
        Map<String, Map<String, Object>> resMap = new HashMap<>();
        if (list.size() > 0) {
            for (TBMaterialStockOnHandEntity tbmSOHItem : list) {
                String mapKeys = tbmSOHItem.getGoodsId() + "," + tbmSOHItem.getMaterialDaptId() + "," + tbmSOHItem.getMaterialWarehouseId();
                Map<String, Object> objectMap = new HashMap<>();
                objectMap.put("soh", tbmSOHItem.getStockOnHand());
                objectMap.put("putTime", tbmSOHItem.getLastPutTime());
                objectMap.put("outTime", tbmSOHItem.getLastOutTime());
                objectMap.put("materialDaptId", tbmSOHItem.getMaterialDaptId());
                objectMap.put("materialWarehouseId", tbmSOHItem.getMaterialWarehouseId());
                if (resMap.containsKey(mapKeys)) {
//                  存在该货品id
                    objectMap.put("soh", Integer.parseInt(String.valueOf(resMap.get(mapKeys).get("soh"))) + tbmSOHItem.getStockOnHand());
//                    如果入库时间<存在的入库时间就更新一下这个入库时间（取小值）
                    if (tbmSOHItem.getLastPutTime() != null) {
                        if (tbmSOHItem.getLastPutTime().compareTo(simpleDateFormat.parse(String.valueOf(resMap.get(mapKeys).get("putTime")))) < 0) {
                            objectMap.put("putTime", tbmSOHItem.getLastPutTime());
                        }
                    }
                    //                    如果出库时间>存在的出库时间就更新一下这个出库时间（取大值）
                    if (tbmSOHItem.getLastOutTime() != null && resMap.get(mapKeys).get("outTime") != null) {
                        if (tbmSOHItem.getLastOutTime().compareTo(simpleDateFormat.parse(String.valueOf(resMap.get(mapKeys).get("outTime")))) > 0) {
                            objectMap.put("outTime", tbmSOHItem.getLastOutTime());
                        }
                    } else {
                        objectMap.put("outTime", null);
                    }
                }
//                更新resMap对象
                resMap.put(mapKeys, objectMap);
            }
        }
        if (resMap.size() > 0) {
            for (String mapKeys : resMap.keySet()) {
//               首先根据货品id获取到一个大集合
                Map<String, Object> objectMap = resMap.get(mapKeys);
                String[] kesList = mapKeys.split(",");
                String goodsid = kesList[0];
//                根据货品id查询得到该货品的详细信息
                TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, goodsid);
//                创建返回实体
                TBMaterialStockOnHandEntity resTbmItem = new TBMaterialStockOnHandEntity();
                resTbmItem.setId(UUID.randomUUID().toString());
                resTbmItem.setGoodsId(goodsid);
                resTbmItem.setMaterialDaptId(String.valueOf(objectMap.get("materialDaptId")));
                resTbmItem.setMaterialWarehouseId(String.valueOf(objectMap.get("materialWarehouseId")));
                resTbmItem.setStockOnHand(Integer.parseInt(String.valueOf(objectMap.get("soh"))));
                resTbmItem.setLastPutTime(objectMap.get("putTime") != null ? simpleDateFormat.parse(String.valueOf(objectMap.get("putTime"))) : null);
                resTbmItem.setLastOutTime(objectMap.get("outTime") != null ? simpleDateFormat.parse(String.valueOf(objectMap.get("outTime"))) : null);
                resTbmItem.setGoodsName(tbGoodsInfoEntity.getGoodsName());
                resTbmItem.setSpecification(tbGoodsInfoEntity.getSpecification());
                resTbmItem.setBaseUnit(tbGoodsInfoEntity.getBaseUnit());
                resTbmItem.setSalesUnit(tbGoodsInfoEntity.getSalesUnit());
                resList.add(resTbmItem);
//              整理的数据写入返回实体集合delete-刘梦祥-2021年12月17日16:28:10（根据需求：物料现存量为0的也要显示）
                /*if (resTbmItem.getStockOnHand() != null && resTbmItem.getStockOnHand() > 0) {
                    resList.add(resTbmItem);
                }*/
            }
        }
        dataGrid.setResults(resList);
        dataGrid.setTotal(resList.size());
        //审批权限查询end
        TagUtil.datagrid(response, dataGrid);
    }


    @RequestMapping(params = {"selectWarehouse"})
    public ModelAndView goWarehouse(WarehouseEntity warehouse, HttpServletRequest req) {
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/warehouseList");
    }


    /**
     * 仓库管理初始化查询
     *
     * @param warehouse
     * @param request
     * @param response
     * @param dataGrid
     */
    @RequestMapping(params = {"warehouseInfo"})
    public void warehouseInfo(WarehouseEntity warehouse, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        CriteriaQuery cq = new CriteriaQuery(WarehouseEntity.class, dataGrid);
        warehouse.setStatus("0");
        warehouse.setDeleteFlag("0");
//      add-刘梦祥-2021年12月2日11:02:02-（根据用户科室添加条件）
        HttpSession session = ContextHolderUtils.getSession();
        TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
        warehouse.setProjectId(tuser.getDepartid());
        HqlGenerateUtil.installHql(cq, warehouse, request.getParameterMap());
        cq.add();
        this.warehouseService.getDataGridReturn(cq, true);
        Collections.sort(dataGrid.getResults());
        TagUtil.datagrid(response, dataGrid);
    }


    //  打开仓库档案页面
    @RequestMapping(params = {"goAdd"})
    public ModelAndView goAdd(HttpServletRequest request) {
//        add-刘梦祥-2021年11月24日21:41:59-（打开仓库档案页面根据需求文档修改：自动获取经办人信息）
        HttpSession session = ContextHolderUtils.getSession();
        TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
        String materialDaptId = request.getParameter("materialDaptId");
        String materialWarehouseId = request.getParameter("materialWarehouseId");
        String materialWarehouse = request.getParameter("materialWarehouse");
        String maintenanceStatus = request.getParameter("maintenanceStatus");
        request.setAttribute("materialDaptId", materialDaptId);
        request.setAttribute("materialWarehouseId", materialWarehouseId);
        request.setAttribute("materialWarehouse", materialWarehouse);
        request.setAttribute("maintenanceStatus", maintenanceStatus);
        request.setAttribute("materialUsername", tuser.getId());
        request.setAttribute("materialUserShowName", tuser.getRealName());
        if (StringUtil.isNotEmpty(request.getParameter("maintenanceType"))) {
            request.setAttribute("maintenanceType", request.getParameter("maintenanceType"));
        }
        if (StringUtil.isNotEmpty(request.getParameter("pageType"))) {
            request.setAttribute("pageType", request.getParameter("pageType"));
        }
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/tBMaterialList-add");
    }


    @RequestMapping(params = {"tBMaterialSonList"})
    public ModelAndView tBMaterialSonList(HttpServletRequest request) {
        String id0 = request.getParameter("materialId");
        String viewFlag = request.getParameter("viewFlag");
        String maintenanceStatus = request.getParameter("maintenanceStatus");
        if (StringUtil.isNotEmpty(id0)) {
            DataGrid dataGrid = new DataGrid();
            CriteriaQuery cq = new CriteriaQuery(TBMaterialInfoEntity.class, dataGrid);
            cq.eq("materialId", id0);
            cq.add();
            this.tBMaterialService.getDataGridReturn(cq, true);
            List<TBMaterialInfoEntity> tbMaterialInfoEntityList = dataGrid.getResults();
            List<DictEntity> dictEntities = this.systemService.queryDict("t_b_goods_category","category_code","category_name");
            Map<String, String> dictEntitiesMap = dictEntities.stream().collect(Collectors.toMap(DictEntity::getTypecode, DictEntity::getTypename));
            List<DictEntity> unitList = this.systemService.queryDict("","metering_calcu_unit","");
            Map<String, String> unitListMap = unitList.stream().collect(Collectors.toMap(DictEntity::getTypecode, DictEntity::getTypename));
            for (TBMaterialInfoEntity tbmItem : tbMaterialInfoEntityList) {
                if (tbmItem.getMaterialInfoGoodsId() != null) {
//                  首先获取货品信息
                    TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, tbmItem.getMaterialInfoGoodsId());
                    if (tbGoodsInfoEntity != null) {
                        //                  计量单位
                        tbmItem.setMaterialInfoModelShowName(unitListMap.getOrDefault(tbGoodsInfoEntity.getBaseUnit(),"未知货品单位"));
                        //                  货品类型
                        tbmItem.setMaterialInfoGoodtypeShowName(dictEntitiesMap.getOrDefault(tbGoodsInfoEntity.getBelongCategory(),"未知货品类型"));
                        //                      规格类型
                        tbmItem.setMaterialInfoMeasure(tbGoodsInfoEntity.getSpecification());
                        //                      写入货品单价
                        tbmItem.setGoodsMoney(tbGoodsInfoEntity.getDefaultProvider());
                        //                      请购货品总金额
                        tbmItem.setGoodsTotalMoney(String.valueOf(Double.parseDouble(tbGoodsInfoEntity.getDefaultProvider()) * tbmItem.getMaterialInfoNum()));
                    }
                }
            }
                request.setAttribute("TBMaterialInfoList", dataGrid.getResults());
            request.setAttribute("viewFlag", viewFlag);
            request.setAttribute("maintenanceStatus", maintenanceStatus);
        }
        if (StringUtil.isNotEmpty(request.getParameter("pageType"))) {
            request.setAttribute("pageType", request.getParameter("pageType"));
        }
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/tBMaterialSonList");
    }

    /**
     * 根据采购单id返回货品列表
     *
     * @return void
     * @author 刘梦祥
     * @Date 2021年11月21日14:20:06
     */
    @RequestMapping(params = {"tBMaterialSonByIdToList"})
    public void tBMaterialSonByIdToList(HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
        String id0 = request.getParameter("materialId");
        String viewFlag = request.getParameter("viewFlag");
        if (StringUtil.isNotEmpty(id0)) {
            CriteriaQuery cq = new CriteriaQuery(TBMaterialInfoEntity.class, dataGrid);
            try {
                cq.eq("materialId", id0);
                cq.gt("materialInfoNoNum", 0);
            } catch (Exception e) {
                throw new BusinessException(e.getMessage());
            }
            cq.add();
            this.tBMaterialService.getDataGridReturn(cq, true);
            //add-刘梦祥-2021年11月21日17:49:01（循环获取货品信息并写入计量单位）
            List<TBMaterialInfoEntity> list = dataGrid.getResults();
            for (TBMaterialInfoEntity tb : list) {
                if (tb.getMaterialInfoGoodsId() != null) {
                    TBGoodsInfoEntity tbg = this.systemService.getEntity(TBGoodsInfoEntity.class, tb.getMaterialInfoGoodsId());
                    if (tbg != null) {
                        tb.setBaseUnit(tbg.getBaseUnit());
                        tb.setMaterialInfoMeasure(tbg.getSpecification());
                        tb.setMaterialInfoModel(tbg.getSalesUnit());
                    }
                }
            }
            request.setAttribute("TBMaterialInfoList", list);
            request.setAttribute("viewFlag", viewFlag);
            //审批权限查询end
            TagUtil.datagrid(response, dataGrid);
        }
    }


    @RequestMapping(params = {"goUpdate"})
    public ModelAndView goUpdate(TBMaterialEntity tBMaterial, HttpServletRequest request) {
        String id = tBMaterial.getId();
        tBMaterial = this.tBMaterialService.getEntity(TBMaterialEntity.class, id);
        SimpleDateFormat simpleDateFormatYMD = new SimpleDateFormat("yyyy-MM-dd");
        if(tBMaterial.getMaterialDate() != null){
            tBMaterial.setMaterialDateStr(simpleDateFormatYMD.format(tBMaterial.getMaterialDate()));
        }
//      根据经办人id获取经办人姓名
        String userId = tBMaterial.getMaterialUsername();
        if (userId != null && !"".equals(userId)) {
            TSBaseUser tsBaseUser = this.systemService.getEntity(TSBaseUser.class, userId);
            request.setAttribute("materialUser", tsBaseUser.getRealName());
        }
        request.setAttribute("tBMaterial", tBMaterial);
        String isView = request.getParameter("viewFlag");
        request.setAttribute("viewFlag", isView);
        if (StringUtil.isNotEmpty(request.getParameter("pageType"))) {
            request.setAttribute("pageType", request.getParameter("pageType"));
        }
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/tBMaterialList-update");
    }

    @RequestMapping(params = {"doUpdate"})
    @ResponseBody
    public AjaxJson doUpdate(TBMaterialEntity tBMaterial, TBMaterialPage tBMaterialPage, HttpServletRequest request) {
        HttpSession session = ContextHolderUtils.getSession();
        TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
        String departid = request.getParameter("materialDaptId");
        String materialUsername = request.getParameter("materialUsername");
        //审批用的
        tBMaterial.setMaterialSpareTwo(tuser.getId());
        tBMaterial.setMaterialApprove("待提交");
        tBMaterial.setMaterialDaptId(departid);
        tBMaterial.setMaterialUsername(materialUsername);
        tBMaterial.setUpdateBy(tuser.getId());
        tBMaterial.setUpdateDate(new Date());
        tBMaterial.setUpdateName(tuser.getRealName());
        AjaxJson j = new AjaxJson();
        String message = "修改成功";
//      修改申购信息的详情信息
        List<TBMaterialInfoEntity> tbMaterialInfoEntityList = tBMaterialPage.getTBMaterialInfoList();
        for (TBMaterialInfoEntity tbMaterialInfoEntity : tbMaterialInfoEntityList) {
            tbMaterialInfoEntity.setUpdateBy(tuser.getId());
            tbMaterialInfoEntity.setUpdateDate(new Date());
            tbMaterialInfoEntity.setUpdateName(tuser.getRealName());
            tbMaterialInfoEntity.setMaterialInfoNoNum(tbMaterialInfoEntity.getMaterialInfoNum());
        }
        tBMaterialPage.setTBMaterialInfoList(null);
        tBMaterialPage.setTBMaterialInfoList(tbMaterialInfoEntityList);
        try {
            this.tBMaterialService.updateMain(tBMaterial, tBMaterialPage.getTBMaterialInfoList());
        } catch (Exception e) {
            e.printStackTrace();
            message = "修改失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }


    @RequestMapping(params = {"toTBGoods"})
    public ModelAndView toTBGoods(HttpServletRequest request) {
        String row = request.getParameter("row");
        String maintenanceStatus = request.getParameter("maintenanceStatus");
        request.setAttribute("row", row);
        request.setAttribute("maintenanceStatus", maintenanceStatus);
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/toTBGoods");
    }

    /**
     * 删除物料申购记录
     *
     * @return
     */
    @RequestMapping(params = "doDel")
    @ResponseBody
    public AjaxJson doDel(TBMaterialEntity tbMaterialEntity, HttpServletRequest request) {
        AjaxJson j = new AjaxJson();
        String message = "物料申购记录删除成功";
        try {
//          首先根据id查询得到物料申购的单个记录
            TBMaterialEntity tbMaterialEntity1 = this.systemService.getEntity(TBMaterialEntity.class, tbMaterialEntity.getId());
            if (tbMaterialEntity1 != null && StringUtil.isNotEmpty(tbMaterialEntity1.getId())) {
//                定义查询条件
                CriteriaQuery criteriaQuery = new CriteriaQuery(TBMaterialInfoEntity.class, new DataGrid());
                criteriaQuery.eq("materialId", tbMaterialEntity1.getId());
                criteriaQuery.add();
                List<TBMaterialInfoEntity> tbMaterialInfoEntityList = this.systemService.getListByCriteriaQuery(criteriaQuery, true);
                if (tbMaterialInfoEntityList != null && tbMaterialInfoEntityList.size() > 0) {
                    for (TBMaterialInfoEntity tb : tbMaterialInfoEntityList) {
                        this.TBMaterialInfoService.deleteEntityById(TBMaterialInfoEntity.class, tb.getId());
                    }
                }
            }
            this.tBMaterialService.deleteEntityById(TBMaterialEntity.class, tbMaterialEntity.getId());
            systemService.addLog(message, Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
        } catch (Exception e) {
            e.printStackTrace();
            j.setSuccess(false);
            message = "物料申购删除失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }

    /**
     * 删除物料到货记录
     *
     * @return
     */
    @RequestMapping(params = "doArrivalDel")
    @ResponseBody
    public AjaxJson doArrivalDel(TBMaterialArrivalEntity tbMaterialArrivalEntity, HttpServletRequest request) {
        AjaxJson j = new AjaxJson();
        try {
//          删除之前首先判断是否已经有其他人有提交操作
            tbMaterialArrivalEntity = this.systemService.getEntity(TBMaterialArrivalEntity.class, tbMaterialArrivalEntity.getId());
            if (tbMaterialArrivalEntity != null) {
                if ("1".equals(tbMaterialArrivalEntity.getReportStatus())) {
                    j.setSuccess(false);
                    j.setMsg("物料到货记录已提交，请刷新后重试！");
                } else {
//                  首先根据id查询得到物料到货的单个记录
                    this.tBMaterialService.deleteEntityById(TBMaterialArrivalEntity.class, tbMaterialArrivalEntity.getId());
                    systemService.addLog("物料到货记录删除成功", Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
                    j.setMsg("物料到货记录删除成功");
                }
            } else {
                j.setSuccess(false);
                j.setMsg("物料到货记录不存在，请刷新后重试！");
            }
        } catch (Exception e) {
            e.printStackTrace();
            j.setSuccess(false);
            j.setMsg("物料到货记录删除失败");
            throw new BusinessException(e.getMessage());
        }
        return j;
    }

    /**
     * 删除物料到货记录
     *
     * @return
     */
    @RequestMapping(params = "doDeliveryDel")
    @ResponseBody
    public AjaxJson doDeliveryDel(TBMaterialDeliveryEntity tbMaterial, HttpServletRequest request) {
        AjaxJson j = new AjaxJson();
        try {
//          首先根据id查询得到物料出货日志表的详细记录
            tbMaterial = this.systemService.getEntity(TBMaterialDeliveryEntity.class, tbMaterial.getId());
            if (tbMaterial != null) {
                if ("1".equals(tbMaterial.getReportStatus())) {
                    j.setSuccess(false);
                    j.setMsg("物料出货记录已提交，请刷新后重试！");
                } else {
                    DataGrid dataGrid = new DataGrid();
                    dataGrid.setRows(999);
                    CriteriaQuery criteriaQuery = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrid);
                    criteriaQuery.eq("deliveryId", tbMaterial.getId());
                    criteriaQuery.add();
                    List<TBMaterialDeliveryInfoEntity> tbMaterialDeliveryInfoEntityList = this.systemService.getListByCriteriaQuery(criteriaQuery, true);
                    if (tbMaterialDeliveryInfoEntityList != null && tbMaterialDeliveryInfoEntityList.size() > 0) {
                        for (TBMaterialDeliveryInfoEntity tbmItem : tbMaterialDeliveryInfoEntityList) {
                            this.systemService.deleteEntityById(TBMaterialDeliveryInfoEntity.class, tbmItem.getId());
                        }
                    }
                    this.tBMaterialService.deleteEntityById(TBMaterialDeliveryEntity.class, tbMaterial.getId());
                    systemService.addLog("物料出货记录删除成功", Globals.Log_Type_DEL, Globals.Log_Leavel_INFO);
                    j.setMsg("物料出货记录删除成功");
                }
            } else {
                j.setSuccess(false);
                j.setMsg("物料出货记录不存在，请刷新后重试！");
            }
        } catch (Exception e) {
            e.printStackTrace();
            j.setSuccess(false);
            j.setMsg("物料出货记录删除失败");
            throw new BusinessException(e.getMessage());
        }
        return j;
    }

    /**
     * 物料申购录入请求
     *
     * @param tBMaterial
     * @param tBMaterialPage
     * @param request
     * @return
     */
    @RequestMapping(params = {"doAdd"})
    @ResponseBody
    public AjaxJson doAdd(TBMaterialEntity tBMaterial, TBMaterialPage tBMaterialPage, HttpServletRequest request) {
        HttpSession session = ContextHolderUtils.getSession();
        TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
        String departid = request.getParameter("materialDaptId");
//      获取货品请购金额总金额
        String goodsTotalMoney = request.getParameter("goodsTotalMoney");
        tBMaterial.setMaterialUsername(tuser.getId());
        //审批用的
        tBMaterial.setMaterialSpareTwo(tuser.getId());
        tBMaterial.setMaterialApprove("待提交");
        tBMaterial.setMaterialDaptId(departid);
        tBMaterial.setCreateBy(tuser.getId());
        tBMaterial.setCreateName(tuser.getRealName());
        tBMaterial.setGoodsTotalMoney(goodsTotalMoney);
        AjaxJson j = new AjaxJson();
        String message = "添加成功";
        try {
//          add-刘梦祥-2021年11月24日20:54:22（BUG修复：添加未到货总数）
            List<TBMaterialInfoEntity> tbMaterialInfoEntityList = tBMaterialPage.getTBMaterialInfoList();
            if (tbMaterialInfoEntityList != null && tbMaterialInfoEntityList.size() > 0) {
                for (TBMaterialInfoEntity item : tbMaterialInfoEntityList) {
                    item.setMaterialInfoNoNum(item.getMaterialInfoNum());
                    item.setCreateBy(tuser.getId());
                    item.setCreateName(tuser.getRealName());
                }
            }
            tBMaterialPage.setTBMaterialInfoList(null);
            tBMaterialPage.setTBMaterialInfoList(tbMaterialInfoEntityList);
            this.tBMaterialService.addMain(tBMaterial, tBMaterialPage.getTBMaterialInfoList());
        } catch (Exception e) {
            e.printStackTrace();
            message = "添加失败";
            throw new BusinessException(e.getMessage());
        }
        j.setMsg(message);
        return j;
    }


    @RequestMapping(params = {"goodsdatagrid"})
    public void goodsdatagrid(TBGoodsInfoEntity tBGoodsInfo, HttpServletRequest request, HttpServletResponse response, DataGrid dataGrid) {
//      判断是否是维修请求
        String maintenanceStatus = request.getParameter("maintenanceStatus");
        CriteriaQuery cq = new CriteriaQuery(TBGoodsInfoEntity.class, dataGrid);
//      首先根据货品名称模糊查询所有的物品分类表数据
        CriteriaQuery cq2 = new CriteriaQuery(TBGoodsCategoryEntity.class, new DataGrid());
        cq2.like("categoryName", "%车辆%");
        cq2.add();
//      得到集合
        List<TBGoodsCategoryEntity> tbGoodsCategoryEntityList = this.systemService.getListByCriteriaQuery(cq2, true);
//      判断非空
        //          定义模糊查询的集合
        List<String> GoodsCode = new ArrayList<>();
        if (tbGoodsCategoryEntityList != null && tbGoodsCategoryEntityList.size() > 0) {
            for (TBGoodsCategoryEntity tbItem : tbGoodsCategoryEntityList) {
                GoodsCode.add(tbItem.getCategoryCode());
            }
        }
        if (GoodsCode.size() > 0) {
            if ("ture".equals(maintenanceStatus)) {
                cq.in("belongCategory", GoodsCode.toArray());
            } else {
                cq.notin("belongCategory", GoodsCode.toArray());
            }
        }
        cq.eq("status","0");
        cq.eq("deleteFlag","0");
        cq.add();
        this.tBGoodsInfoService.getDataGridReturn(cq, true);
        TagUtil.datagrid(response, dataGrid);
    }

    @RequestMapping(params = {"exportXlsOrder"})
    public void exportXlsOrder(String id, HttpServletRequest request, HttpServletResponse response, ModelMap map) throws IOException {
//      权限标识
        int butRule = 0;
        String requestUserTag = "false";
        if (StringUtil.isNotEmpty(request.getParameter("butRule"))) {
            butRule = Integer.parseInt(request.getParameter("butRule"));
        }
//      审批流程用户标识
        if (StringUtil.isNotEmpty(request.getParameter("requestUserTag"))) {
            requestUserTag = request.getParameter("requestUserTag");
        }
        id = request.getParameter("id");
//      根据id获取科室信息
        TBMaterialEntity t = this.systemService.getEntity(TBMaterialEntity.class, id);
        String materialDaptStr = "";
        if (StringUtil.isNotEmpty(t.getMaterialDaptId())) {
            TSDepart tsDepart = this.systemService.getEntity(TSDepart.class, t.getMaterialDaptId());
            materialDaptStr = tsDepart.getDepartname();
        } else {
            materialDaptStr = "科室信息获取异常";
        }
//      获取申购月份
        if(t.getMaterialDate() != null){
            materialDaptStr += "-" + simpleDateFormat.format(t.getMaterialDate()).substring(5, 7);
        }else if(t.getCreateDate() != null){
            materialDaptStr += "-" + simpleDateFormat.format(t.getCreateDate()).substring(5, 7);
        }
//      文件名称
        String fileName = materialDaptStr + "月份-申购表";
        if (StringUtil.isNotEmpty(request.getParameter("requestType"))) {
            fileName = materialDaptStr + "月份-采购表";
        }
        DataGrid dataGrid = new DataGrid();
        TBMaterialInfoEntity tBMaterialInfoEntityA = new TBMaterialInfoEntity();
        tBMaterialInfoEntityA.setMaterialId(id);
        CriteriaQuery cq = new CriteriaQuery(TBMaterialInfoEntity.class, dataGrid);
        HqlGenerateUtil.installHql(cq, tBMaterialInfoEntityA, request.getParameterMap());
        this.TBMaterialInfoService.getDataGridReturn(cq, true);
        List<TBMaterialInfoEntity> details = dataGrid.getResults();
        HSSFWorkbook wb = new HSSFWorkbook();
        HSSFSheet sheet = wb.createSheet(fileName);
        HSSFRow row1 = sheet.createRow(0);
        HSSFCell cell = row1.createCell(0);
        cell.setCellValue(fileName);
        sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 5));
        HSSFRow row2 = sheet.createRow(1);
        row2.createCell(0).setCellValue("货品名称");
        row2.createCell(1).setCellValue("计量单位");
        row2.createCell(2).setCellValue("规格型号");
        row2.createCell(3).setCellValue("货品分类");
        row2.createCell(4).setCellValue("数量");
        row2.createCell(5).setCellValue("备注");
//      暂存货品请购总金额
        Integer totalGoodsMoney = 0;
        for (int i = 2; i < details.size() + 2; i++) {
            HSSFRow row3 = sheet.createRow(i);
            TBMaterialInfoEntity tBMaterialInfoEntity = details.get(i - 2);
//          根据请购货品详情表中的货品id得到详细的货品信息
            if (StringUtil.isNotEmpty(tBMaterialInfoEntity.getMaterialInfoGoodsId())) {
                TBGoodsInfoEntity TBGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, tBMaterialInfoEntity.getMaterialInfoGoodsId());
                row3.createCell(0).setCellValue(TBGoodsInfoEntity != null ? TBGoodsInfoEntity.getGoodsName() : "货品不存在");
//                计量单位需要中文转义
                row3.createCell(1).setCellValue(TBGoodsInfoEntity != null ? this.systemService.getType(TBGoodsInfoEntity.getBaseUnit(), "metering_calcu_unit").getTypename() : "货品不存在");
                row3.createCell(2).setCellValue(TBGoodsInfoEntity != null ? TBGoodsInfoEntity.getSpecification() : "货品不存在");
//                货品分类需要中文转义
                List<DictEntity> dictEntities = this.systemService.queryDict("t_b_goods_category","category_code","category_name");
                Map<String, String> dictEntitiesMap = dictEntities.stream().collect(Collectors.toMap(DictEntity::getTypecode, DictEntity::getTypename));
                row3.createCell(3).setCellValue(TBGoodsInfoEntity != null ? dictEntitiesMap.getOrDefault(TBGoodsInfoEntity.getBelongCategory(),"货品分类查询失败") : "货品不存在");
                row3.createCell(4).setCellValue(tBMaterialInfoEntity.getMaterialInfoNum());
                row3.createCell(5).setCellValue(tBMaterialInfoEntity.getMaterialInfoRemarks());
                totalGoodsMoney += Integer.parseInt(TBGoodsInfoEntity != null ? TBGoodsInfoEntity.getDefaultProvider() : "0") * tBMaterialInfoEntity.getMaterialInfoNum();
            } else {
                row3.createCell(0).setCellValue("货品查询失败");
                row3.createCell(1).setCellValue("货品查询失败");
                row3.createCell(2).setCellValue("货品查询失败");
                row3.createCell(3).setCellValue("货品查询失败");
                row3.createCell(4).setCellValue("货品查询失败");
                row3.createCell(5).setCellValue("货品查询失败");
            }
        }
        HSSFRow totalRow = sheet.createRow(details.size() + 3);
        totalRow.createCell(0).setCellValue("经办人");
        totalRow.createCell(1).setCellValue(t.getCreateName());
        totalRow.createCell(2).setCellValue("");
        totalRow.createCell(3).setCellValue("");
//      只有审批人下载文件时才显示总金额
        if (butRule == 2 || butRule == 3 || butRule == 6 || butRule == 7 || "true".equals(requestUserTag)) {
            totalRow.createCell(4).setCellValue("请购货品总金额");
            totalRow.createCell(5).setCellValue(totalGoodsMoney);
        }
        ServletOutputStream servletOutputStream = response.getOutputStream();
        response.reset();
        fileName = URLEncoder.encode(fileName, "utf-8");
        response.setHeader("Content-disposition", "attachment; filename=" + fileName + ".xls;filename*=utf-8''" + fileName + ".xls");
        response.setContentType("application/msexcel");
        wb.write((OutputStream) servletOutputStream);
        servletOutputStream.close();
    }

    /**
     * 物料出货打印页面跳转
     * @author 刘梦祥
     * @date 2022年8月12日15:05:48
     * @param request
     * @return
     */
    @RequestMapping(params = {"goPrint"})
    public ModelAndView goPrint(HttpServletRequest request) {
        String id = request.getParameter("id");
        HttpSession session = ContextHolderUtils.getSession();
        TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
        if(tuser != null && tuser.getRealName() != null){
            String userName = tuser.getRealName();
            request.setAttribute("userName",userName);
        }
        String departName = "科室信息获取失败！";
//      获取导出时间（时间格式暂定为年月日）
        String materialDaptStr = simpleDateFormat.format(new Date()).substring(0, 10);
        request.setAttribute("materialDaptStr",materialDaptStr);

//      首先根据id查询物料出货表列表
        DataGrid dataGrid1 = new DataGrid();
        dataGrid1.setRows(99999);
        CriteriaQuery criteriaQuery = new CriteriaQuery(TBMaterialDeliveryEntity.class, dataGrid1);
        criteriaQuery.eq("id", id);
        criteriaQuery.eq("reportStatus", "1");
        criteriaQuery.add();
        List<TBMaterialDeliveryEntity> tbMaterialDeliveryEntities = this.systemService.getListByCriteriaQuery(criteriaQuery, true);

        // 返回对象
        List<Map<String,String>> printInfos = new ArrayList<>();
        // 合计[单价、数量、合计]
        double providerSum = 0.00;
        int outNumSum = 0;
        double providerSums = 0.00;

        if (tbMaterialDeliveryEntities != null && tbMaterialDeliveryEntities.size() > 0) {
            if (tbMaterialDeliveryEntities.size() == 1) {
                // 根据出货id得到出货详细数据
                DataGrid dataGrid = new DataGrid();
                dataGrid.setRows(999);
                CriteriaQuery cq = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrid);
                // update-刘梦祥-2021年12月17日16:33:33（需要查询出所有的已确认出货的记录）
                cq.eq("deliveryId", tbMaterialDeliveryEntities.get(0).getId());
                cq.add();
                List<TBMaterialDeliveryInfoEntity> tbMaterialDeliveryInfoEntityList = this.TBMaterialInfoService.getListByCriteriaQuery(cq, true);
                if(tbMaterialDeliveryInfoEntityList != null && tbMaterialDeliveryInfoEntityList.size() > 0){
                    for (TBMaterialDeliveryInfoEntity item: tbMaterialDeliveryInfoEntityList){
                        Map<String,String> printInfo = new HashMap<>();
                        // 转换为科室（根据详细出货日志得到出货日志表信息）
                        if("科室信息获取失败！".equals(departName)){
                            TBMaterialDeliveryEntity tbMaterialDelivery = this.systemService.getEntity(TBMaterialDeliveryEntity.class, item.getDeliveryId());
                            if (tbMaterialDelivery != null && StringUtil.isNotEmpty(tbMaterialDelivery.getMaterialDaptId())) {
                                departName = this.systemService.getType(tbMaterialDelivery.getMaterialDaptId(), "departName").getTypename();
                            }
                        }
                        // 转换货品名称(根据货品id,得到货品名称)
                        TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, item.getGoodsId());
                        if (tbGoodsInfoEntity != null && StringUtil.isNotEmpty(tbGoodsInfoEntity.getGoodsName())) {
                            printInfo.put("goodsName",tbGoodsInfoEntity.getGoodsName());
                            printInfo.put("defaultProvider",tbGoodsInfoEntity.getDefaultProvider());
                            printInfo.put("defaultProviderSum",String.valueOf(item.getOutNum()*Integer.parseInt(tbGoodsInfoEntity.getDefaultProvider())));

                            providerSum += Double.parseDouble(tbGoodsInfoEntity.getDefaultProvider());
                            providerSums += Double.parseDouble(String.valueOf(item.getOutNum()*Integer.parseInt(tbGoodsInfoEntity.getDefaultProvider())));
                        } else {
                            printInfo.put("goodsName","货品名称加载失败！");
                            printInfo.put("defaultProvider","货品单价加载失败！");
                            printInfo.put("defaultProviderSum","货品总价计算失败！");
                        }
                        outNumSum += item.getOutNum();
                        printInfo.put("outNum",String.valueOf(item.getOutNum()));
                        // 根据领用车id得到领用车号
                        if (item.getReceiverCarId() != null) {
                            CarEntity tbCar = this.systemService.getEntity(CarEntity.class, item.getReceiverCarId());
                            if(tbCar != null){
                                printInfo.put("plate",tbCar.getPlate());
                            }else{
                                printInfo.put("plate","");
                            }
                        } else {
                            printInfo.put("plate","领用车信息查询失败！");
                        }
                        printInfos.add(printInfo);
                    }
                }
            }
        }

        request.setAttribute("providerSum",providerSum);
        request.setAttribute("outNumSum",outNumSum);
        request.setAttribute("providerSums",providerSums);
        request.setAttribute("departName",departName);
        request.setAttribute("printInfos",printInfos);
        return new ModelAndView("cn/com/lzt/sign/tbmaterial/materialDelivery-print");
    }

    /**
     * 物料出货导出
     *
     * @param id
     * @param request
     * @param response
     * @param map
     * @throws IOException
     */
    @RequestMapping(params = {"exportDelivery"})
    public void exportDelivery(String id, HttpServletRequest request, HttpServletResponse response, ModelMap map) throws IOException {
//      权限标识
        String[] ids = request.getParameter("ids").split(",");
        HttpSession session = ContextHolderUtils.getSession();
        TSUser tuser = (TSUser) session.getAttribute("LOCAL_CLINET_USER");
//      获取导出时间（时间格式暂定为年月日）
        String materialDaptStr = simpleDateFormat.format(new Date()).substring(0, 10);
//      首先根据id查询物料出货表列表
        DataGrid dataGrid1 = new DataGrid();
        dataGrid1.setRows(99999);
        CriteriaQuery criteriaQuery = new CriteriaQuery(TBMaterialDeliveryEntity.class, dataGrid1);
        criteriaQuery.in("id", ids);
        criteriaQuery.eq("reportStatus", "1");
        criteriaQuery.add();
        List<TBMaterialDeliveryEntity> tbMaterialDeliveryEntities = this.systemService.getListByCriteriaQuery(criteriaQuery, true);
        if (tbMaterialDeliveryEntities != null && tbMaterialDeliveryEntities.size() > 0) {
            if (tbMaterialDeliveryEntities.size() == 1) {
//              文件名称
                String fileName = "出库单";
//              根据出货id得到出货详细数据
                DataGrid dataGrid = new DataGrid();
                dataGrid.setRows(999);
                CriteriaQuery cq = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrid);
//              update-刘梦祥-2021年12月17日16:33:33（需要查询出所有的已确认出货的记录）
                cq.eq("deliveryId", tbMaterialDeliveryEntities.get(0).getId());
                cq.add();
                List<TBMaterialDeliveryInfoEntity> tbMaterialDeliveryInfoEntityList = this.TBMaterialInfoService.getListByCriteriaQuery(cq, true);
                HSSFWorkbook wb = new HSSFWorkbook();
                HSSFSheet sheet = wb.createSheet(fileName);
                HSSFRow row1 = sheet.createRow(0);
                HSSFCell cell = row1.createCell(0);
                cell.setCellValue(fileName);
                sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 7));
                HSSFRow totalRow = sheet.createRow(1);
                totalRow.createCell(0).setCellValue("导出日期：");
                totalRow.createCell(1).setCellValue(materialDaptStr);
                totalRow.createCell(2).setCellValue("");
                totalRow.createCell(3).setCellValue("");
                totalRow.createCell(4).setCellValue("");
                totalRow.createCell(5).setCellValue("");
                totalRow.createCell(6).setCellValue("导出人：");
                totalRow.createCell(7).setCellValue(tuser.getRealName());
                HSSFRow row2 = sheet.createRow(2);
                row2.createCell(0).setCellValue("序号");
                row2.createCell(1).setCellValue("科室");
                row2.createCell(2).setCellValue("货品名称");
                row2.createCell(3).setCellValue("数量");
                // add-刘梦祥-2022年8月12日14:08:46（新增单价和总价两个字段）
                row2.createCell(4).setCellValue("单价");
                row2.createCell(5).setCellValue("总价");
                row2.createCell(6).setCellValue("领用车号");
                row2.createCell(7).setCellValue("领用人签字");
//              暂存货品请购总金额
                for (int i = 3; i < tbMaterialDeliveryInfoEntityList.size() + 3; i++) {
                    HSSFRow row3 = sheet.createRow(i);
                    TBMaterialDeliveryInfoEntity item = tbMaterialDeliveryInfoEntityList.get(i - 3);
                    row3.createCell(0).setCellValue(i - 2);
//                  转换为科室（根据详细出货日志得到出货日志表信息）
                    TBMaterialDeliveryEntity tbMaterialDelivery = this.systemService.getEntity(TBMaterialDeliveryEntity.class, item.getDeliveryId());
                    if (tbMaterialDelivery != null && StringUtil.isNotEmpty(tbMaterialDelivery.getMaterialDaptId())) {
                        row3.createCell(1).setCellValue(this.systemService.getType(tbMaterialDelivery.getMaterialDaptId(), "departName").getTypename());
                    } else {
                        row3.createCell(1).setCellValue("科室信息获取失败！");
                    }
//                  转换货品名称(根据货品id,得到货品名称)
                    TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, item.getGoodsId());
                    if (tbGoodsInfoEntity != null && StringUtil.isNotEmpty(tbGoodsInfoEntity.getGoodsName())) {
                        row3.createCell(2).setCellValue(tbGoodsInfoEntity.getGoodsName());
                        row3.createCell(4).setCellValue(tbGoodsInfoEntity.getDefaultProvider());
                        row3.createCell(5).setCellValue(item.getOutNum()*Integer.parseInt(tbGoodsInfoEntity.getDefaultProvider()));
                    } else {
                        row3.createCell(2).setCellValue("货品名称加载失败！");
                        row3.createCell(4).setCellValue("货品单价加载失败！");
                        row3.createCell(5).setCellValue("货品总价计算失败！");
                    }
                    row3.createCell(3).setCellValue(item.getOutNum());
//                  根据领用车id得到领用车号
                    if (item.getReceiverCarId() != null) {
                        CarEntity tbCar = this.systemService.getEntity(CarEntity.class, item.getReceiverCarId());
                        if(tbCar != null){
                            row3.createCell(6).setCellValue(tbCar.getPlate());
                        }else{
                            row3.createCell(6).setCellValue("");
                        }
                    } else {
                        row3.createCell(6).setCellValue("领用车信息查询失败！");
                    }
                    row3.createCell(7).setCellValue("");
                }
                ServletOutputStream servletOutputStream = response.getOutputStream();
                response.reset();
                fileName = URLEncoder.encode(fileName, "utf-8");
                response.setHeader("Content-disposition", "attachment; filename=" + fileName + ".xls;filename*=utf-8''" + fileName + ".xls");
                response.setContentType("application/msexcel");
                wb.write((OutputStream) servletOutputStream);
                servletOutputStream.close();
            } else {
                Map<String, byte[]> fileBytes = new HashMap<>();
                String nowTime = simpleDateFormat.format(new Date());
                String nowTimeMStr = nowTime.substring(5, 7);
//              如果有多个的话
                for (TBMaterialDeliveryEntity tbMds : tbMaterialDeliveryEntities) {
//                  详细文件名称
                    String fileName = nowTimeMStr + "月份出库单";
//                  科室名称
                    String departName = "";
//                  根据出货id得到出货详细数据
                    DataGrid dataGrid = new DataGrid();
                    dataGrid.setRows(999);
                    CriteriaQuery cq = new CriteriaQuery(TBMaterialDeliveryInfoEntity.class, dataGrid);
//                  update-刘梦祥-2021年12月17日16:33:33（需要查询出所有的已确认出货的记录）
                    cq.eq("deliveryId", tbMds.getId());
                    cq.add();
                    List<TBMaterialDeliveryInfoEntity> tbMaterialDeliveryInfoEntityList = this.TBMaterialInfoService.getListByCriteriaQuery(cq, true);
                    HSSFWorkbook wb = new HSSFWorkbook();
                    HSSFSheet sheet = wb.createSheet(fileName);
                    HSSFRow row1 = sheet.createRow(0);
                    HSSFCell cell = row1.createCell(0);
                    cell.setCellValue(fileName);
                    sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 7));
                    HSSFRow totalRow = sheet.createRow(1);
                    totalRow.createCell(0).setCellValue("导出日期：");
                    totalRow.createCell(1).setCellValue(materialDaptStr);
                    totalRow.createCell(2).setCellValue("");
                    totalRow.createCell(3).setCellValue("");
                    totalRow.createCell(4).setCellValue("");
                    totalRow.createCell(5).setCellValue("");
                    totalRow.createCell(6).setCellValue("导出人：");
                    totalRow.createCell(7).setCellValue(tuser.getRealName());
                    HSSFRow row2 = sheet.createRow(2);
                    row2.createCell(0).setCellValue("序号");
                    row2.createCell(1).setCellValue("科室");
                    row2.createCell(2).setCellValue("货品名称");
                    row2.createCell(3).setCellValue("数量");
                    // add-刘梦祥-2022年8月12日14:08:46（新增单价和总价两个字段）
                    row2.createCell(4).setCellValue("单价");
                    row2.createCell(5).setCellValue("总价");
                    row2.createCell(6).setCellValue("领用车号");
                    row2.createCell(7).setCellValue("领用人签字");
//                  暂存货品请购总金额
                    for (int i = 3; i < tbMaterialDeliveryInfoEntityList.size() + 3; i++) {
                        HSSFRow row3 = sheet.createRow(i);
                        TBMaterialDeliveryInfoEntity item = tbMaterialDeliveryInfoEntityList.get(i - 3);
                        row3.createCell(0).setCellValue(i - 2);
//                      转换为科室（根据详细出货日志得到出货日志表信息）
                        TBMaterialDeliveryEntity tbMaterialDelivery = this.systemService.getEntity(TBMaterialDeliveryEntity.class, item.getDeliveryId());
                        if (tbMaterialDelivery != null && StringUtil.isNotEmpty(tbMaterialDelivery.getMaterialDaptId())) {
                            row3.createCell(1).setCellValue(this.systemService.getType(tbMaterialDelivery.getMaterialDaptId(), "departName").getTypename());
                            if ("".equals(departName)) {
                                departName = this.systemService.getType(tbMaterialDelivery.getMaterialDaptId(), "departName").getTypename();
                            }
                        } else {
                            row3.createCell(1).setCellValue("科室信息获取失败！");
                        }
//                      转换货品名称(根据货品id,得到货品名称)
                        TBGoodsInfoEntity tbGoodsInfoEntity = this.systemService.getEntity(TBGoodsInfoEntity.class, item.getGoodsId());
                        if (tbGoodsInfoEntity != null && StringUtil.isNotEmpty(tbGoodsInfoEntity.getGoodsName())) {
                            row3.createCell(2).setCellValue(tbGoodsInfoEntity.getGoodsName());
                            row3.createCell(4).setCellValue(tbGoodsInfoEntity.getDefaultProvider());
                            row3.createCell(5).setCellValue(item.getOutNum()*Integer.parseInt(tbGoodsInfoEntity.getDefaultProvider()));
                        } else {
                            row3.createCell(2).setCellValue("货品名称加载失败！");
                            row3.createCell(4).setCellValue("货品单价加载失败！");
                            row3.createCell(5).setCellValue("货品总价计算失败！");
                        }
                        row3.createCell(3).setCellValue(item.getOutNum());
//                      根据领用车id得到领用车号
                        if (item.getReceiverCarId() != null) {
                            CarEntity tbCar = this.systemService.getEntity(CarEntity.class, item.getReceiverCarId());
                            if(tbCar != null){
                                row3.createCell(6).setCellValue(tbCar.getPlate());
                            }else{
                                row3.createCell(6).setCellValue("");
                            }
                        } else {
                            row3.createCell(6).setCellValue("领用车信息查询失败！");
                        }
                        row3.createCell(7).setCellValue("");
                    }
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    try {
                        wb.write(bos);
                    } finally {
                        bos.close();
                    }
                    byte[] bytes = bos.toByteArray();
                    if (fileBytes.containsKey(departName + fileName)) {
                        int fileIndex = 1;
                        String fileNameExcel = departName + fileName;
                        while (fileBytes.containsKey(fileNameExcel)) {
                            fileNameExcel = departName + fileName + "(" + fileIndex + ")";
                            fileIndex++;
                        }
                        fileBytes.put(fileNameExcel, bytes);
                    } else {
                        fileBytes.put(departName + fileName, bytes);
                    }
                }
                String ls_filename = URLEncoder.encode("出库单.zip", "utf-8");// 创建文件
                String destFileDir = ResourceUtil.getSystempPath() + File.separator + "出库单.zip";
                File zipFile = new File(destFileDir);
                if (!zipFile.exists()) {
                    zipFile.createNewFile();
                }
                FileOutputStream fileOutputStream = new FileOutputStream(zipFile);
                ZipOutputStream zipOutputStream = new ZipOutputStream(fileOutputStream);
                fileBytes.forEach((k, v) -> {
                    //写入一个条目，我们需要给这个条目起个名字，相当于起一个文件名称
                    try {
                        zipOutputStream.putNextEntry(new ZipEntry(k + ".xls"));
                        zipOutputStream.write(v);
                    } catch (IOException e) {
                        e.printStackTrace();
                        System.err.print("写入文件失败");
                    }
                });
                zipOutputStream.closeEntry();
                zipOutputStream.close();
                // 清空response
                response.reset();
                InputStream fis = new BufferedInputStream(new FileInputStream(destFileDir));
                // 设置response的Header
                response.setContentType("text/html;charset=utf-8");
                request.setCharacterEncoding("UTF-8");
                response.addHeader("Content-Length", "" + zipFile.length());
                OutputStream toClient = new BufferedOutputStream(response.getOutputStream());
                response.setContentType("application/octet-stream");
                response.setHeader("Content-disposition", "attachment;filename="
                        + new String(ls_filename.getBytes("utf-8"), "ISO8859-1"));
                int bytesRead = 0;
                byte[] buffer = new byte[8192];
                while ((bytesRead = fis.read(buffer, 0, 8192)) != -1) {
                    toClient.write(buffer, 0, bytesRead);
                }
                toClient.write(buffer);
                toClient.flush();
                toClient.close();
                fis.close();
            }
        }
    }

    /**
     * @param byteList 文件字节码Map，k:fileName，v：byte[]
     */
    public void zipFile(String destFileDir, Map<String, byte[]> byteList) {
        try {
            File zipFile = new File(destFileDir);
            if (!zipFile.exists()) {
                zipFile.createNewFile();
            }
            FileOutputStream fileOutputStream = new FileOutputStream(zipFile);
            ZipOutputStream zipOutputStream = new ZipOutputStream(fileOutputStream);
            byteList.forEach((k, v) -> {
                //写入一个条目，我们需要给这个条目起个名字，相当于起一个文件名称
                try {
                    zipOutputStream.putNextEntry(new ZipEntry(k + ".xlsx"));
                    zipOutputStream.write(v);
                } catch (IOException e) {
                    e.printStackTrace();
                    System.err.print("写入文件失败");
                }
            });
            //关闭条目
            zipOutputStream.closeEntry();
            zipOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.err.print("压缩文件失败");
        }
    }
}