添加危废信息展示以及app调用接口

李宇

2021-01-13 5ce314bb05eef373bd25b0b2e289a01bf6e5b6c4

 src/main/java/com/nanometer/smartlab/api/ApiAction.java

@@ -7,21 +7,18 @@
import com.google.common.collect.Maps;
import com.nanometer.smartlab.controller.BaseController;
import com.nanometer.smartlab.controller.MenuController;
import com.nanometer.smartlab.dao.OpeReagentStatusDao;
import com.nanometer.smartlab.dao.SysLaboratoryContainerDao;
import com.nanometer.smartlab.dao.SysWarehouseContainerDao;
import com.nanometer.smartlab.entity.*;
import com.nanometer.smartlab.entity.SysWarning;
import com.nanometer.smartlab.entity.enumtype.ApiStatus;
import com.nanometer.smartlab.entity.enumtype.SeeFlag;
import com.nanometer.smartlab.entity.dto.*;
import com.nanometer.smartlab.entity.enumtype.*;
import com.nanometer.smartlab.exception.ApiException;
import com.nanometer.smartlab.exception.BusinessException;
import com.nanometer.smartlab.exception.ExceptionEnumCode;
import com.nanometer.smartlab.model.ResponseModel;
import com.nanometer.smartlab.service.*;
import com.nanometer.smartlab.util.Constants;
import com.nanometer.smartlab.util.FacesUtils;
import com.nanometer.smartlab.util.IDUtils;
import com.nanometer.smartlab.util.MessageUtil;
import com.nanometer.smartlab.util.*;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
@@ -29,6 +26,7 @@
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.primefaces.context.RequestContext;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
@@ -38,6 +36,7 @@
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
@@ -65,6 +64,8 @@
    private BaseMetaService baseMetaService;
    @Resource
    private InterfaceService interfaceService;
    @Resource
    private SysWarehouseService sysWarehouseService;

    @Resource
    private SysWarningService sysWarningService;
@@ -78,6 +79,14 @@
    private SysLaboratoryContainerDao sysLaboratoryContainerDao;
    @Resource
    private SysWarehouseContainerDao sysWarehouseContainerDao;
    @Resource
    private DangerousEncodeService dangerousEncodeService;
    @Resource
    private EncodeReplaceDictService encodeReplaceDictService;
    @Resource
    private SysLaboratoryService sysLaboratoryService;
    @Resource
    private HazardousWasteService hazardousWasteService;
    @Value("${institute.url}")
    String instituteUrl;

@@ -222,35 +231,6 @@
        return retJSON.toJSONString();
    }

    @ResponseBody
    @RequestMapping(value = "/userListByContainerCode")
    public Object userListByContainerCode(@RequestParam String containerCode,@RequestParam String startTime, @RequestParam String endTime) throws ApiException {
      logger.info("userListByContainerCode start...containerCode= " + containerCode
            + ",startTime=" + startTime
            + ",endTime=" + endTime);

      List<SysUser> userList = interfaceService.getUserListByContainerCode(containerCode, startTime, endTime);

        List<Map> datalist = Lists.newArrayListWithCapacity(userList.size());
        for (SysUser user : userList) {
            Map<String, Object> map = Maps.newHashMapWithExpectedSize(5);
            datalist.add(map);
            map.put("name", user.getName());
            map.put("role", user.getSeeFlag().getKey());
            map.put("validFlag", user.getValidFlag().getKey());
            map.put("idcard", user.getIdCard());
            map.put("point", user.getPoint());
            map.put("unit", user.getCompany());
            map.put("Arp", user.getArp());
            map.put("departmentName", user.getDepartment());

        }
        logger.info("getUserInfo end...");
        return ResponseModel.getOkInstence(datalist);
    }




    @ResponseBody
    @RequestMapping(value = "/openCabinetDoor")
@@ -357,6 +337,7 @@
            retJSON.put("code", e.getApiStatus().getRetCode());
            retJSON.put("message", e.getErrorMessage());
        } catch (Exception e) {
            e.printStackTrace();
            retJSON.put("code", ApiStatus.SYS_ERR.getRetCode());
            StackTraceElement[] stackTraceElements = e.getStackTrace();

@@ -563,9 +544,14 @@
            map.put("reagentType", opeReagentStatus.getReagent().getReagentType());
            map.put("deadline", opeReagentStatus.getReagent().getDeadline());
            map.put("specification", opeReagentStatus.getReagent().getReagentFormat());
            map.put("masterMetering", opeReagentStatus.getReagent().getMainMetering());
            map.put("itemNumber", opeReagentStatus.getReagent().getReagentType());
            map.put("itemNumber", opeReagentStatus.getArticleNumber());
            map.put("producer", opeReagentStatus.getReagent().getProductHome());
            if (opeReagentStatus.getReagent().getMainMetering() == null){
                map.put("masterMetering",opeReagentStatus.getReagent().getReagentUnit());
            }else{
                map.put("masterMetering", opeReagentStatus.getReagent().getMainMetering());
            }

        }
        logger.info("getReagentInfo end...");
        return ResponseModel.getOkInstence(datalist);
@@ -860,6 +846,11 @@
         }

         String updateTime = dataJson.getString("updateTime");
            if (sdf.parse(updateTime).after(new Date())) {
                retJSON.put("code", "400");
                retJSON.put("message", "发送时间不准确");
                return retJSON.toJSONString();
            }

         SysContainerSensors sysContainerSensors = new SysContainerSensors();
         sysContainerSensors.setContainerId(containerCode);
@@ -1070,7 +1061,7 @@

    //从柜子的设备码根据设备的所在实验室的课题组的课题组下的所有用户，没有课题组则返回用部门搜索
    @ResponseBody
    @RequestMapping(value = "/userListByContainerCodeNew")
    @RequestMapping(value = "/userListByContainerCode")
    public Object userListByContainerCodeNew(@RequestParam String containerCode,@RequestParam String startTime, @RequestParam String endTime) throws ApiException {
        logger.info("userListByContainerCodeNew start...containerCode= " + containerCode
                + ",startTime=" + startTime
@@ -1096,9 +1087,681 @@
            map.put("unit", user.getCompany());
            map.put("Arp", user.getArp());
            map.put("departmentName", user.getDepartment());
            map.put("project", user.getProject());

        }
        logger.info("getUserInfo end...");
        return ResponseModel.getOkInstence(datalist);
    }


    //危化品编码接口
    @ResponseBody
    @RequestMapping(value = "/dangerousEncodeInfo")
    public Object getDangerousEncodeInfo(@RequestParam String reagentName, @RequestParam String cas) {
        List<DangerousEncodeVo> datalist = new ArrayList<>();
        if (StringUtils.isNotBlank(reagentName) || StringUtils.isNotBlank(cas)){
            datalist = dangerousEncodeService.selectByReagentName(reagentName,cas);
            for (DangerousEncodeVo dangerousEncodeVo : datalist){
                if (StringUtils.isNotBlank(dangerousEncodeVo.getContainerNumber())){
                    if (dangerousEncodeVo.getContainerNumber().startsWith("0")){
                        dangerousEncodeVo.setContainerName("普通型");
                    }else if (dangerousEncodeVo.getContainerNumber().startsWith("1")){
                        dangerousEncodeVo.setContainerName("阻燃型");
                    }else if (dangerousEncodeVo.getContainerNumber().startsWith("2")){
                        dangerousEncodeVo.setContainerName("抗腐蚀型");
                    }else if (dangerousEncodeVo.getContainerNumber().startsWith("3")){
                        dangerousEncodeVo.setContainerName("防爆型");
                    }else if (dangerousEncodeVo.getContainerNumber().startsWith("4")){
                        dangerousEncodeVo.setContainerName("有毒称重型");
                    }
                }
            }
        }else {
            return ResponseModel.getParamInstence("reagentName,cas");
        }

        return ResponseModel.getOkInstence(datalist);
    }

    //生成24位危化品编码
    @ResponseBody
    @RequestMapping(value = "/generatorCode")
    public Object generatorCode(@RequestParam String reagentName,@RequestParam String containerName,
                                @RequestParam String factory, @RequestParam String specs,@RequestParam String pack) {
        String code = "";
        int count = 0;
        DangerousEncode dangerousEncode = new DangerousEncode();
        if (StringUtils.isNotBlank(reagentName)){
            dangerousEncode = dangerousEncodeService.selectByName(reagentName);
            if (null != dangerousEncode){
                code = dangerousEncode.getCode();
                count = dangerousEncode.getCount();
            }else {
                return ResponseModel.getErrInstance("无法找到该试剂");
            }
        }else {
            return ResponseModel.getParamInstence("reagentName");
        }

        StringBuffer buffer = new StringBuffer(code);

        if (StringUtils.isNotBlank(containerName)){
            if (containerName.equals("普通型")){
                buffer.replace(0, 1, "0");
            }else if (containerName.equals("阻燃型")){
                buffer.replace(0, 1, "1");
            }else if (containerName.equals("抗腐蚀型")){
                buffer.replace(0, 1, "2");
            }else if (containerName.equals("防爆型")){
                buffer.replace(0, 1, "3");
            }else if (containerName.equals("有毒称重型")){
                buffer.replace(0, 1, "4");
            }
        }else {
            return ResponseModel.getParamInstence("containerName");
        }

        String regex="^[A-F0-9]+$";

        if (StringUtils.isNotBlank(factory) && factory.matches(regex)){
            buffer.replace(2, 3, factory);
        }else {
            return ResponseModel.getParamInstence("factory");
        }

        if (StringUtils.isNotBlank(specs) && specs.matches(regex)){
            buffer.replace(3, 4, specs);
        }else {
            return ResponseModel.getParamInstence("specs");
        }

        if (StringUtils.isNotBlank(pack) && pack.matches(regex)){
            buffer.replace(18, 19, pack);
        }else {
            return ResponseModel.getParamInstence("pack");
        }

        String countHex = Integer.toHexString(count).toUpperCase();
        if (countHex.length() == 1){
            buffer.replace(23, 24, countHex);
        }else if (countHex.length() == 2){
            buffer.replace(22, 24, countHex);
        }else if (countHex.length() == 3){
            buffer.replace(21, 24, countHex);
        }else if (countHex.length() == 4){
            buffer.replace(20, 24, countHex);
        }else if (countHex.length() == 5){
            buffer.replace(19, 24, countHex);
        }
        code = buffer.toString();

        dangerousEncode.setCount(dangerousEncode.getCount()+1);
        dangerousEncodeService.updateOne(dangerousEncode);

        return ResponseModel.getOkInstence(code);
    }

    /**
     * 获取替换字典
     *
     */
    @ResponseBody
    @RequestMapping("getEncodeReplaceDict")
    public Object getEncodeReplaceDict(@RequestParam String type) {
        try {
            ReplaceDictType rdType = ReplaceDictType.parse(Integer.parseInt(type));
            EncodeReplaceDict encodeReplaceDict = new EncodeReplaceDict();
            encodeReplaceDict.setType(rdType);
            List<EncodeReplaceDict> data = encodeReplaceDictService.selectAll(encodeReplaceDict, null, null);
            return ResponseModel.getOkInstence(data);
        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }

    }

    /**
     * 获取编码
     *
     */
    @ResponseBody
    @RequestMapping("getDangerousEncode")
    public Object getDangerousEncode(@RequestParam(required = false) String reagentName, @RequestParam(required = false) String cas) {
        try {
            List<DangerousEncode> data = dangerousEncodeService.selectByCodeAndName(null, reagentName, cas, null);
            return ResponseModel.getOkInstence(data);
        } catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
    }

    }
    /**
     * 获取仓库信息
     */
    @ResponseBody
    @RequestMapping("getWarehouseInfo")
    public Object getWarehouseInfo() {
        try {
            List<SysWarehouseDto> data = sysWarehouseService.getWarehouseList();
            return ResponseModel.getOkInstence(data);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }

    }


    /**
    * @Description: 获取所有人员，人员相关实验室，实验室相关试剂柜
    * @date 2020/12/23 16:47
    */
    @ResponseBody
    @RequestMapping("getApplyPersonDetailInfo")
    public Object getApplyPersonDetailInfo() {
        try {
            List data = sysUserService.getUserInfo();
            return ResponseModel.getOkInstence(data);
        } catch (Exception e) {
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }

    }


   /**
   * @Description: 入库
   * @date 2020/12/24 14:19
   */
    @ResponseBody
    @RequestMapping("putInStorage")
    public Object putInWarehouse(@RequestBody InWarehouseInfoDto inWarehouseInfo) {
        try {

            if (inWarehouseInfo.getReagentCode() != null && inWarehouseInfo.getReagentCode().size() > 0) {

                for (int i = 0; i < inWarehouseInfo.getReagentCode().size(); i++) {
                    String code = inWarehouseInfo.getReagentCode().get(i);
                    DangerousEncode dangerousEncode = new DangerousEncode();
                    //5-8位
                    String reagentCode = code.substring(4, 8);
                    //数据库存储的前缀00空着
                    dangerousEncode.setReagentCode("00"+reagentCode);
                    List<DangerousEncode> dangerousEncodes =
                            dangerousEncodeService.selectAll(dangerousEncode,null,null);
                    //1.编码存在校验
                    if (dangerousEncodes.size() <1){
                        return ResponseModel.getErrInstance("该试剂危化品编码不存在");
                    }

                    //2.重复入库校验  无论任何状态
                    OpeReagentStatus ors = opeReagentStatusService.getOpeReagentStatusByReagentCode(code);
                    if (ors != null) {
                        return ResponseModel.getErrInstance("该试剂危化品编码已存在");
                    }

                }

                //3.入库
                sysWarehouseService.putInWarehouse(inWarehouseInfo);
                return ResponseModel.getOkInstence("入库成功");
            } else {
                return ResponseModel.getErrInstance("无试剂条码");
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }

    }


    /**
     * @Description: 试剂领用到实验室
     * @date 2020/12/24 14:19
     */
    @ResponseBody
    @RequestMapping("reagentReceiving")
    public Object reagentReceiving(@RequestBody ReagentReceivingDto reagentReceiving) {
        try {
            if (reagentReceiving.getReagentCode() != null && reagentReceiving.getReagentCode().size() > 0) {

                //1.校验仓库是否有该试剂
                for (int i = 0; i < reagentReceiving.getReagentCode().size(); i++) {
                    String reagentCode = reagentReceiving.getReagentCode().get(i);
                    //去试剂状态查找 是否有此试剂条码
                    OpeReagentStatus ors = opeReagentStatusService.getOpeReagentStatusByReagentCode(reagentCode);
                    if (ors == null || ors.getStatus() != ArrivalStatus.WAREHOUSE){
                        return ResponseModel.getErrInstance("仓库无此试剂");
                    }
                }
                //2.领用
                sysWarehouseService.reagentReceiving(reagentReceiving);
                return ResponseModel.getOkInstence("领用成功");
            } else {
                return ResponseModel.getErrInstance("无效试剂条码");
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }

    }

    /**
     * @Description: 试剂转移到另一个柜子
     * @date 2020/12/24 14:19
     */
//    @ResponseBody
//    @RequestMapping("reagentTransfer")
//    public Object reagentReceiving(@RequestBody ReagentReceivingDto reagentReceiving) {
//        try {
//            if (this.selectedTmpList == null || this.selectedTmpList.size() == 0) {
//                FacesUtils.warn("请选择申领试剂。");
//                return;
//            }
//
//            if (this.userId == null) {
//                FacesUtils.warn("请选择申领人。");
//                return;
//            }
//            //领用单
//            printTable = null;
//            printTable = new Hashtable();
//            List<ApplyListDto> applyList = new ArrayList<>();
//            Map applyPersonInfo = sysUserService.getUser(userId);
//            printTable.put("head", instituteName);
//            printTable.put("title", "领用单");
//            printTable.put("applyPerson", applyPersonInfo.get("name"));
//            printTable.put("department", applyPersonInfo.get("meta_value"));
//            printTable.put("date", Utils.now("yyyy-MM-dd"));
//            printTable.put("phone", applyPersonInfo.get("phone"));
//
//            //int size = 0;
//            int sum = 0;
//            List<OpeWarehouseReserve> list=new ArrayList<>();
//            List<OpeWarehouseReserve> list2=new ArrayList<>();
//            for (OpeWarehouseReserve selectWarehouseReserve : this.selectedTmpList) {
//                if(selectWarehouseReserve.getFlag()==1){
//                    list.add(selectWarehouseReserve);
//                }else{
//                    list2.add(selectWarehouseReserve);
//                }
//            }
//            if(list.size()>0&&list!=null){
//                for (OpeWarehouseReserve selectWarehouseReserve : list) {
//                    List<String> reagentCodes = selectWarehouseReserve.getReagentCodes();
//                    if (reagentCodes != null && reagentCodes.size() > 0)
//                        for (String opeReagentStatusId : reagentCodes) {
//                            OpeReagentStatus opeReagentStatus = this.opeReagentStatusService
//                                    .getOpeReagentStatus(opeReagentStatusId);
//                            if (!this.opeReagentStatusService.isAllowWarehouseUse(opeReagentStatus)) {
//                                FacesUtils.warn("只能申领在仓库的试剂。");
//                                return;
//                            }else {
//                                opeReagentStatus.setHouseId(laboratoryId);
//                                opeReagentStatus.setContainerId(laboratoryContainerId);
//                                this.opeReagentStatusDao.updateOpeReagentStatusDao(opeReagentStatus);//更新试剂状态表
//                                OpeLaboratoryReserve lr=new OpeLaboratoryReserve();
//                                lr.setReagentId(selectWarehouseReserve.getReagentId());
//                                lr.setHouseId(laboratoryId);
//                                lr.setContainerId(laboratoryContainerId);
//                                lr.setReserve(selectWarehouseReserve.getSelectNum());
//                                lr.setUserId(userId);
//                                lr.setValidFlag(ValidFlag.VALID);
//                                this.opeLaboratoryReserveService.insert(lr);
//                            }
//                            //else {
//                            //size++;
//                            //}
//                        }
//                    ApplyListDto lis = new ApplyListDto();
//                    Map reagentDetail = sysReagentService.getReagentDetail(selectWarehouseReserve.getReagentId());
//                    lis.setNum(String.valueOf(selectWarehouseReserve.getSelectNum())); //数量
//                    lis.setMainMetering(String.format("%s%s", reagentDetail.get("main_metering"), reagentDetail.get("unit")));
//                    lis.setControlProducts((String) reagentDetail.get("controlProducts"));
//                    lis.setProductName((String) reagentDetail.get("name"));
//                    lis.setReagentFormat((String) reagentDetail.get("reagentFormat"));
//                    lis.setProductCode((String)reagentDetail.get("productCode"));
//                    lis.setMemo((String)reagentDetail.get("memo"));
//                    applyList.add(lis);
//                    sum += selectWarehouseReserve.getSelectNum();
//                }
//
//                //if (size == 0) {
//                //FacesUtils.warn("未选择一个条形码。");
//                //return;
//                //}
//                this.opeWarehouseReserveService.claim(list, userId,projectNum);
//            }
//            if(list2.size()>0&&list2!=null){
//                List<OpeApply> opeList=new ArrayList<>();
//                //this.opeApplyService.getOpeApplyList(null,null,null,null,null)
//                for(int i=0;i<list2.size();i++){
//                    OpeApply opeApply=new OpeApply();
//                    opeApply.setArticleNumber(list2.get(i).getArticleNumber());
//                    opeApply.setHouseId(laboratoryId);
//                    opeApply.setContainerId(laboratoryContainerId);
//                    opeApply.setReagent(this.sysReagentService.getSysReagent(list2.get(i).getReagentId()));
//                    opeApply.setStartReagentCode(list2.get(i).getStartReagentCode2());
//                    opeApply.setEndReagentCode(list2.get(i).getEndReagentCode2());
//                    opeList.add(opeApply);
//                    OpeLaboratoryReserve lr=new OpeLaboratoryReserve();
//                    lr.setReagentId(list2.get(i).getReagentId());
//                    lr.setHouseId(laboratoryId);
//                    lr.setContainerId(laboratoryContainerId);
//                    lr.setReserve(list2.get(i).getSelectNum());
//                    lr.setUserId(userId);
//                    lr.setValidFlag(ValidFlag.VALID);
//                    this.opeLaboratoryReserveService.insert(lr);
//                    //opeList.add(this.opeApplyService.getOpeApply(list2.get(i).getId()));
//                    ApplyListDto lis = new ApplyListDto();
//                    Map reagentDetail = sysReagentService.getReagentDetail(list2.get(i).getReagentId());
//
//                    lis.setNum(String.valueOf(list2.get(i).getSelectNum())); //数量
//                    lis.setMainMetering(String.format("%s%s", reagentDetail.get("main_metering"), reagentDetail.get("unit")));
//                    lis.setControlProducts((String) reagentDetail.get("controlProducts"));
//                    lis.setProductName((String) reagentDetail.get("name"));
//                    lis.setReagentFormat((String) reagentDetail.get("reagentFormat"));
//                    lis.setProductCode((String)reagentDetail.get("productCode"));
//                    lis.setMemo((String)reagentDetail.get("memo"));
//                    applyList.add(lis);
//
//                    sum += list2.get(i).getSelectNum();
//                }
//                this.opeWarehouseReserveService.reagentDStore2(opeList,userId);
//                for(int i=0;i<list2.size();i++){
//                    list2.get(i).setReserve(list2.get(i).getReserve()-list2.get(i).getSelectNum());
//                    opeWarehouseReserveDao.updateOpeWarehouseReserve(list2.get(i));
//                }
//
//
//                //opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve()-opeWarehouseReserve.getSelectNum());
//                //opeWarehouseReserveDao.updateOpeWarehouseReserve(opeWarehouseReserve);
//                //this.opeWarehouseReserveService.claim(list2, userId,projectNum);
//            }
//
//            //领用票最后一行
//            applyList.add(new ApplyListDto("合计", "", "", "", "", String.valueOf(sum), ""));
//            printTable.put("applyList", applyList);
//
//            FacesUtils.info("申领成功。");
//            RequestContext.getCurrentInstance().execute("PF('printDialog').show()");
////            this.menuController.goToPage(Constants.PAGE_WAREHOUSE_STOCK_MNG, Constants.PAGE_WAREHOUSE_REAGENT_USE_NEW);
//        } catch (Exception e) {
//            logger.error(e.getMessage(), e);
//            FacesUtils.warn("操作失败。");
//        }
//    }

    /**
     * @Description: 危废登录
     * @date 2020/12/29 14:13
     */
    @ResponseBody
    @RequestMapping("hazardousWaste/login")
    public Object hazardousWaste(@RequestBody HazardousWasteUser user) {
        try {
            String account = user.getAccount();
            if (StringUtils.isBlank(account)){
                return  ResponseModel.getErrInstance("账户名为空");
            }

            HazardousWasteUser sysUser = sysUserService.getUserByAccount(account);
            if (sysUser == null){
                return  ResponseModel.getErrInstance("账户名不存在");
            }else{
                if (sysUser.getPassword().equals(MD5Utils.encode(user.getPassword()))){
                    if (sysUser.getAdminFlag() != 0){
                        user = sysUser;
                    }else{
                        return ResponseModel.getErrInstance("用户不属于危废处理人员");
                    }
                    return ResponseModel.getOkInstence(user);
                }else{
                    return ResponseModel.getErrInstance("密码错误");
                }
            }

        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }
    }

    /**
     * 修改密码
     *
     */
    @ResponseBody
    @RequestMapping("hazardousWaste/changePwd")
    public Object changePwd(@RequestBody HazardousWasteUser user){
        try {
            if (StringUtils.isBlank(user.getAccount())){
                return  ResponseModel.getErrInstance("账户名为空");
            }
            SysUser sysUser = sysUserService.getSysUserByAccount(user.getAccount());
            if (sysUser == null){
                return  ResponseModel.getErrInstance("账户名不存在");
            }else{
                if (sysUser.getPassword().equals(MD5Utils.encode(user.getPassword()))){

                    SysUser newUser = new SysUser();
                    newUser = sysUser;
                    String PW_PATTERN = "(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[~!@#$%^&*_.]).{8,}";
                    if (!user.getNewpassword().matches(PW_PATTERN)){
                        return ResponseModel.getErrInstance("密码必须8位以上,并且包含大小写字母、数字、特殊符号三种以上");
                    }else {
                        newUser.setPassword(MD5Utils.encode(user.getNewpassword()));
                        sysUserService.updateSysUser(newUser);
                        return ResponseModel.getOkInstence("修改成功");
                    }
                }else{
                    return ResponseModel.getErrInstance("原密码错误");
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }
    }

    /**
     * 根据课题组名称获取部门、地址、所属人员
     *
     */
    @ResponseBody
    @RequestMapping("hazardousWaste/getLabAndUser")
    public Object getLabAndUser(@RequestParam(required=true) String project){
        try {
            if (StringUtils.isBlank(project)){
                return  ResponseModel.getErrInstance("课题组不能为空");
            }
            LaboratoryVo laboratoryVo = new LaboratoryVo();
            List<LaboratoryVo.Laboratory> laboratoryList = sysLaboratoryService.getLaboratoryByProject(project);
            List<LaboratoryVo.LaboratoryUser> laboratoryUserList = sysUserService.getUserByProject(project);
            laboratoryVo.setLaboratoryList(laboratoryList);
            laboratoryVo.setLaboratoryUsers(laboratoryUserList);
            return ResponseModel.getOkInstence(laboratoryVo);
        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }
    }

    /**
     * 录入危废信息
     *
     */
    @ResponseBody
    @RequestMapping("hazardousWaste/putWasteInfo")
    public Object putWasteInfo(@RequestBody HazardousWaste hazardousWaste){
        try {
            if (StringUtils.isBlank(hazardousWaste.getDepartment()) || StringUtils.isBlank(hazardousWaste.getApplyPerson())
            || StringUtils.isBlank(hazardousWaste.getProject()) || StringUtils.isBlank(hazardousWaste.getUnit())
                    || StringUtils.isBlank(hazardousWaste.getCreator())){
                return  ResponseModel.getErrInstance("部门、单位、课题组、确认者、创建者、不能为空");
            }
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
            hazardousWaste.setTid(sdf.format(new Date()));
            hazardousWaste.setCreateTime(new Date());
            hazardousWaste.setStatus("待确认");
            if (hazardousWaste.getAcid()== null){
                hazardousWaste.setAcid(new BigDecimal(0));
            }
            if (hazardousWaste.getAlkali()== null){
                hazardousWaste.setAlkali(new BigDecimal(0));
            }
            if (hazardousWaste.getOrganic()== null){
                hazardousWaste.setOrganic(new BigDecimal(0));
            }
            if (hazardousWaste.getSolid()== null){
                hazardousWaste.setSolid(new BigDecimal(0));
            }
            if (hazardousWaste.getMedical()== null){
                hazardousWaste.setMedical(new BigDecimal(0));
            }
            hazardousWaste.setUpdator(hazardousWaste.getCreator());
            hazardousWaste.setUpdatetime(new Date());
            hazardousWasteService.insertInfo(hazardousWaste);
            return ResponseModel.getOkInstence("添加成功");
        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }
    }


    /**
     * 根据用户名和危废角色获取危废列表
     *
     */
    @ResponseBody
    @RequestMapping("hazardousWaste/getWasteInfo")
    public Object getLabAndUser(@RequestParam(required=true) int adminFlag,@RequestParam(required=true) String name,@RequestParam(required=false) String status
    ,@RequestParam(required=false) String starttime,@RequestParam(required=false) String endtime){
        try {
            if (StringUtils.isBlank(name)){
                return  ResponseModel.getErrInstance("姓名不能为空");
            }
            List<HazardousWaste> hazardousWasters = new ArrayList<>();
            if (adminFlag == 2){
                hazardousWasters = hazardousWasteService.setAllWasters(starttime,endtime,status,null);
            }else if (adminFlag == 1) {
                hazardousWasters = hazardousWasteService.setAllWasters(starttime,endtime,status,name);
            }
            return ResponseModel.getOkInstence(hazardousWasters);
        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }
    }

    /**
     * 更新订单状态(确认订单、拒绝订单)
     */
    @ResponseBody
    @RequestMapping("hazardousWaste/changeStatus")
    public Object getLabAndUser(@RequestParam(required=true) String tid,@RequestParam(required=true) String status,
                                @RequestParam(required=true) String updator){
        try {
            if (StringUtils.isBlank(tid) || StringUtils.isBlank(status)){
                return  ResponseModel.getErrInstance("单号、状态不能为空");
            }
            HazardousWaste hazardousWaste = hazardousWasteService.selectByTid(tid);
            if (hazardousWaste != null){
                if (!hazardousWaste.getStatus().equals("待确认")){
                    return ResponseModel.getErrInstance("单据不为待确认无法修改");
                }else if (status.equals("已确认") || status.equals("已拒绝")){
                    hazardousWaste.setStatus(status);
                    hazardousWaste.setUpdator(updator);
                    hazardousWaste.setUpdatetime(new Date());
                    hazardousWasteService.updateWaste(hazardousWaste);
                    return ResponseModel.getOkInstence("修改成功");
                }else {
                    return ResponseModel.getErrInstance("单号状态不正确");
                }
            }else {
                return ResponseModel.getErrInstance("单号不存在");
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }
    }

    /**
     * 修改危废信息
     *
     */
    @ResponseBody
    @RequestMapping("hazardousWaste/editWasteInfo")
    public Object editWasteInfo(@RequestBody HazardousWaste hazardousWaste){
        try {
            if (StringUtils.isBlank(hazardousWaste.getTid()) ||StringUtils.isBlank(hazardousWaste.getUpdator())){
                return  ResponseModel.getErrInstance("单号、更新人不能为空");
            }
            HazardousWaste waste = hazardousWasteService.selectByTid(hazardousWaste.getTid());
            if (waste != null){
                if (!waste.getStatus().equals("已拒绝")){
                    return ResponseModel.getErrInstance("单据不为已拒绝无法修改");
                }else {
                    waste.setStatus("待确认");
                    if (hazardousWaste.getAcid()== null){
                        waste.setAcid(new BigDecimal(0));
                    }else {
                        waste.setAcid(hazardousWaste.getAcid());
                    }
                    if (hazardousWaste.getAlkali()== null){
                        waste.setAlkali(new BigDecimal(0));
                    }else {
                        waste.setAlkali(hazardousWaste.getAlkali());
                    }
                    if (hazardousWaste.getOrganic()== null){
                        waste.setOrganic(new BigDecimal(0));
                    }else {
                        waste.setOrganic(hazardousWaste.getOrganic());
                    }
                    if (hazardousWaste.getSolid()== null){
                        waste.setSolid(new BigDecimal(0));
                    }else {
                        waste.setSolid(hazardousWaste.getSolid());
                    }
                    if (hazardousWaste.getMedical()== null){
                        waste.setMedical(new BigDecimal(0));
                    }else {
                        waste.setMedical(hazardousWaste.getMedical());
                    }
                    waste.setUpdator(hazardousWaste.getUpdator());
                    waste.setUpdatetime(new Date());
                    hazardousWasteService.updateWaste(waste);
                    return ResponseModel.getOkInstence("修改成功");
                }
            }else {
                return ResponseModel.getErrInstance("单号不存在");
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.info(e);
            return ResponseModel.getErrInstance("系统出错");
        }
    }


}