package com.nanometer.smartlab.service;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.nanometer.smartlab.api.ApiAction;
import com.nanometer.smartlab.dao.*;
import com.nanometer.smartlab.entity.*;
import com.nanometer.smartlab.entity.enumtype.ApiStatus;
import com.nanometer.smartlab.entity.enumtype.ArrivalStatus;
import com.nanometer.smartlab.entity.enumtype.SeeFlag;
import com.nanometer.smartlab.entity.enumtype.ValidFlag;
import com.nanometer.smartlab.entity.enumtype.WarningLevel;
import com.nanometer.smartlab.exception.ApiException;
import com.nanometer.smartlab.util.IDUtils;

import org.apache.commons.lang.StringUtils;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@Service("interfaceService")
public class InterfaceServiceImpl implements InterfaceService {

    private static Logger logger = Logger.getLogger(ApiAction.class);
    @Lazy
	@Resource
	private OpeUseFlowService opeUseFlowService;
	@Resource
    private SysWarningService sysWarningService;
    @Resource(name = "sysWarningDao")
    SysWarningDao sysWarningDao;
    @Resource(name = "sysWarehouseDao")
    SysWarehouseDao sysWarehouseDao;

    @Resource(name = "sysLaboratoryDao")
    SysLaboratoryDao sysLaboratoryDao;

    @Resource(name = "sysWarehouseContainerDao")
    SysWarehouseContainerDao sysWarehouseContainerDao;

    @Resource(name = "sysLaboratoryContainerDao")
    SysLaboratoryContainerDao sysLaboratoryContainerDao;

    @Resource(name="sysUserDao")
    SysUserDao sysUserDao;

    @Resource(name="opeReagentStatusDao")
    OpeReagentStatusDao opeReagentStatusDao;

    @Resource(name="opeUseFlowDao")
    OpeUseFlowDao opeUseFlowDao;

    @Resource(name="sysAlarmDao")
    SysAlarmDao sysAlarmDao;

    @Resource(name="sysAlarmPersonDao")
    SysAlarmPersonDao sysAlarmPersonDao;

    @Resource(name="baseMetaDao")
    BaseMetaDao baseMetaDao;

    @Resource(name="sysControllerDao")
    SysControllerDao sysControllerDao;

    @Resource
    SysLaboratoryContainerService sysLaboratoryContainer;

    @Value("${message.url}")
    String url;

    @Value("${message.signature}")
    String signature;

    @Value("${message.head}")
    String head;

    @Value("${message.enable}")
    boolean enable;

    @Value("${alarm.url}")
    String alarmUrl;

    @Value("${alarm.type}")
    String alarmType;


    @Override
    @Transactional(propagation = Propagation.REQUIRED)
	public void AutheTestCabinet(String userId, JSONObject jsonObject) throws ApiException {
    	if (!jsonObject.containsKey("createTime")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[createTime]");
        }
    	String createTime = jsonObject.getString("createTime");
    	Timestamp updateTime = new Timestamp(System.currentTimeMillis());
        try {
        	updateTime = Timestamp.valueOf(createTime);
        } catch (Exception e) {
            e.printStackTrace();
        }

        if (!jsonObject.containsKey("controllerData")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerData]");
        }

        if (!jsonObject.containsKey("containerDataList")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerDataList]");
        }
        // 主控数据
        JSONObject controllerJson = jsonObject.getJSONObject("controllerData");
        // 货柜数据
        JSONArray containerDataJSONArr = jsonObject.getJSONArray("containerDataList");

        if (!controllerJson.containsKey("controllerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerCode]");
        }
        if (!controllerJson.containsKey("validFlag")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[validFlag]");
        }

        // 数据Check部分

        String controllerCode = controllerJson.getString("controllerCode");
        Integer validFlagVal = controllerJson.getInteger("validFlag");

        if (controllerCode == null || "".equals(controllerCode)) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[controllerCode]");
        }
        if (validFlagVal == null) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[validFlag]");
        }
        ValidFlag validFlag = ValidFlag.parse(validFlagVal);
        if (validFlag == null) {
            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[validFlag]");
        }
        // 1. 确定主控机Code是否存在
        // 2. 如果主控机Code不存在，抛异常，说主控机Code不存在
        // 注： 货柜Code先不检查了，允许新增+更新混合的情况
        SysController sysController = sysControllerDao.getSysControllerByCode(controllerCode);
        if (sysController == null) {
            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[controllerCode]");
        }


        // 数据保存部分
        // 1.循环货柜信息
        //    1.1 根据货柜Code，检查货柜信息是否存在
        // 		1.1.1  如果存在，将货柜信息更新到DB中
        //		1.1.2  如果不存在，将货柜信息保存到DB中
        // 注意：参数货柜位置	place，如果是0 ：仓库        插入sys_warehouse_container表
        //                         如果是1：实验室   插入sys_laboratory_container表
        // containerLeft 对应 DB character_left
        // containerRight 对应 DB character_right
        // createTimestamp 对应 DB create_time
        Iterator<Object> containerDateIterator = containerDataJSONArr.iterator();
        while (containerDateIterator.hasNext()) {
		//        	货柜条码	containerCode	String	○
		//        	货柜名称	containerName	String
		//        	有效标识	validFlag	Integer	○
		//        	场所编码	barCode	String	○
		//        	货柜类型	type	Integer	○
		//        	货柜位置	place	Integer	○
		//        	左柜危险性质	left	String
		//        	右边危险性质	right	String

            JSONObject containerDateJson = JSONObject.parseObject(containerDateIterator.next().toString());
            // 货柜条码	containerCode	String	○
            if (!containerDateJson.containsKey("containerCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerCode]");
            }
            String containerCode = containerDateJson.getString("containerCode");
            if (containerCode == null || "".equals(containerCode.trim())) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[containerCode]");
            }
    		// 有效标识	validFlag	Integer	○
            if (!containerDateJson.containsKey("validFlag")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[validFlag]");
            }
            Integer containerValidFlagVal = containerDateJson.getInteger("validFlag");
            if (containerValidFlagVal == null) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "validFlag");
            }
            ValidFlag containerValidFlag = ValidFlag.parse(containerValidFlagVal);
            if (containerValidFlag == null) {
                throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "validFlag");
            }
    		// 货柜类型	type	Integer	○
            if (!containerDateJson.containsKey("type")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST);
            }
            Integer containerType = containerDateJson.getInteger("type");
            if (containerType == null) {
                throw new ApiException(ApiStatus.PARAM_NULL);
            }
    		// 货柜位置	place	Integer	○
            if (!containerDateJson.containsKey("place")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST);
            }
            Integer containerPlace = containerDateJson.getInteger("place");
            if (containerPlace == null) {
                throw new ApiException(ApiStatus.PARAM_NULL);
            }
    		// 场所编码	barCode	String	○
            if (!containerDateJson.containsKey("barCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[barCode]");
            }
            String barCode = containerDateJson.getString("barCode");
            if (barCode == null || "".equals(barCode)) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[barCode]");
            }

            Integer containerLeft = containerDateJson.getInteger("left");
            Integer containerRight = containerDateJson.getInteger("right");

            // 仓库试剂柜场合
            if (containerPlace == 0) {
                SysWarehouseContainer sysWarehouseContainer = sysWarehouseContainerDao.getSysWarehouseContainerByContainerCode(containerCode);
                // 试剂柜未事前在Web添加
                if (sysWarehouseContainer == null) {
                	throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[ContainerCode Authe ERR]");
                }
                SysWarehouse sysWarehouse = sysWarehouseDao.getSysWarehouseByBarCode(barCode);
                if (sysWarehouse == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[barCode]");
                }
                // 获取货柜类型数据字典
                Map<String, String> metaMap = new HashMap<>();
                metaMap.put("groupId", "container_type");
                metaMap.put("metaKey", String.valueOf(containerType));

				List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
				if (baseMetaList == null || baseMetaList.size() != 1) {
					throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[type]");
				}

				sysWarehouseContainer.setWarehouseId(sysWarehouse.getId());
				sysWarehouseContainer.setType(baseMetaList.get(0).getId());
				sysWarehouseContainer.setContainerCode(containerCode);
				sysWarehouseContainer.setCreateTime(updateTime);
				sysWarehouseContainer.setUpdateTime(updateTime);
				sysWarehouseContainer.setValidFlag(containerValidFlag);
				sysWarehouseContainer.setControllerCode(controllerCode);

				// 可能不能直接存，需要转换成数据字典
				if (containerLeft != null) {
					sysWarehouseContainer.setCharacterLeft(String.valueOf(containerLeft));
				}
				if (containerRight != null) {
					sysWarehouseContainer.setCharacterRight(String.valueOf(containerRight));
				}

				sysWarehouseContainerDao
						.updateSysWarehouseContainerForInterface(sysWarehouseContainer);

			// 实验室试剂柜场合
            } else if (containerPlace == 1) {
                SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao.getSysLaboratoryContainerByContainerCode(containerCode);
                // 试剂柜未事前在Web添加
                if (sysLaboratoryContainer == null) {
                	throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[ContainerCode Authe ERR]");
                }
                SysLaboratory sysLaboratory = sysLaboratoryDao.getSysLaboratoryByBarCode(barCode);
                if (sysLaboratory == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[barCode]");
                }

                Map<String, String> metaMap = new HashMap<>();
                metaMap.put("groupId", "container_type");
                metaMap.put("metaKey", String.valueOf(containerType));

                List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
				if (baseMetaList == null || baseMetaList.size() != 1) {
					throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[type]");
				}

				sysLaboratoryContainer.setLaboratoryId(sysLaboratory.getId());
				sysLaboratoryContainer.setType(baseMetaList.get(0).getId());
				sysLaboratoryContainer.setContainerCode(containerCode);
				sysLaboratoryContainer.setCreateTime(updateTime);
				sysLaboratoryContainer.setUpdateTime(updateTime);

				sysLaboratoryContainer.setValidFlag(containerValidFlag);
				sysLaboratoryContainer.setControllerCode(controllerCode);

				// 可能不能直接存，需要转换成数据字典
				if (containerLeft != null) {
					sysLaboratoryContainer.setCharacterLeft(String.valueOf(containerLeft));
				}

				if (containerRight != null) {
					sysLaboratoryContainer.setCharacterRight(String.valueOf(containerRight));
				}

				int containerCount = sysLaboratoryContainerDao
						.updateSysLaboratoryContainerForInterface(sysLaboratoryContainer);

				if (containerCount == 0) {
					throw new ApiException(ApiStatus.PARAM_ERR,
							ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode updateTime]");
				}
            }
        }

	}

	@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void registerTestCabinet(String userId, JSONObject jsonObject) throws ApiException {
        long createTimestamp = jsonObject.getLong("createTime");

        if (!jsonObject.containsKey("controllerData")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerData]");
        }

        JSONObject controllerJSON = jsonObject.getJSONObject("controllerData");

        if (!jsonObject.containsKey("containerDataList")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerDataList]");
        }

        JSONArray containerDataJSONArr = jsonObject.getJSONArray("containerDataList");

        if (!controllerJSON.containsKey("controllerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerCode]");
        }

        String controllerCode = controllerJSON.getString("controllerCode");

        if (controllerCode == null || "".equals(controllerCode.trim())) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[controllerCode]");
        }

        if (!controllerJSON.containsKey("controllerName")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerName]");
        }

        String controllerName = controllerJSON.getString("controllerName");

        if (controllerName == null || "".equals(controllerName.trim())) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[controllerName]");
        }

        if (!controllerJSON.containsKey("validFlag")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[validFlag]");
        }

        Integer validFlagVal = controllerJSON.getInteger("validFlag");

        if (validFlagVal == null) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[validFlag]");
        }

        ValidFlag validFlag = ValidFlag.parse(validFlagVal);
        if (validFlag == null) {
            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[validFlag]");
        }


        // 数据Check部分
        // 1. 确定主控机Code是否存在

        SysController sysController = new SysController();
        sysController.setControllerCode(controllerCode);
        sysController.setControllerName(controllerName);
        sysController.setValidFlag(validFlag);
        sysController.setCreateTime(new Timestamp(createTimestamp));
        sysController.setUpdateTime(new Timestamp(createTimestamp));

        try {
            sysControllerDao.insertSysController(sysController);
        } catch (Exception e) {
        	e.printStackTrace();
            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[controllerCode]");
        }

        // 2. 如果主控机Code存在，抛异常，说主控机Code已存在

        // 3. 先循环获取注册接口中所有货柜条码，check货柜条码是否存在，如果存在，抛异常，说货柜条码Code已存在
        // 注意：参数货柜位置	place，如果是0 ：仓库        查询sys_warehouse_container表
        //                         如果是1：实验室  查询sys_laboratory_container表

        Iterator<Object> containerDateIterator = containerDataJSONArr.iterator();
        while (containerDateIterator.hasNext()) {
            JSONObject containerDateJson = JSONObject.parseObject(containerDateIterator.next().toString());

            if (!containerDateJson.containsKey("containerCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerCode]");
            }

            String containerCode = containerDateJson.getString("containerCode");

            if (containerCode == null || "".equals(containerCode.trim())) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[containerCode]");
            }

            if (!containerDateJson.containsKey("validFlag")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[validFlag]");
            }

            Integer containerValidFlag = containerDateJson.getInteger("validFlag");

            if (containerValidFlag == null) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[validFlag]");
            }

            if (!containerDateJson.containsKey("type")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[type]");
            }

            Integer containerType = containerDateJson.getInteger("type");

            if (containerType == null) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[type]");
            }

            if (!containerDateJson.containsKey("barCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[barCode]");
            }

            String barCode = containerDateJson.getString("barCode");

            if (barCode == null || "".equals(barCode)) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[barCode]");
            }

            if (!containerDateJson.containsKey("place")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[place]");
            }

            Integer containerPlace = containerDateJson.getInteger("place");

            if (containerPlace == null) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[place]");
            }

            Integer containerLeft = containerDateJson.getInteger("left");
            Integer containerRight = containerDateJson.getInteger("right");


            if (containerPlace == 0) {
                SysWarehouseContainer sysWarehouseContainer = sysWarehouseContainerDao.getSysWarehouseContainerByContainerCode(containerCode);
                if (sysWarehouseContainer != null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode]");
                }

                SysWarehouse sysWarehouse = sysWarehouseDao.getSysWarehouseByBarCode(barCode);
                if (sysWarehouse == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[barCode]");
                }

                Map<String, String> metaMap = new HashMap<>();
                metaMap.put("groupId", "container_type");
                metaMap.put("metaKey", String.valueOf(containerType));

                List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
                if (baseMetaList == null || baseMetaList.size() != 1) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[type]");
                }


                SysWarehouseContainer tempSysWarehouseContainer = new SysWarehouseContainer();
                tempSysWarehouseContainer.setWarehouseId(sysWarehouse.getId());
                tempSysWarehouseContainer.setType(baseMetaList.get(0).getMetaValue());
                tempSysWarehouseContainer.setContainerCode(containerCode);
                tempSysWarehouseContainer.setCreateTime(new Timestamp(createTimestamp));
                tempSysWarehouseContainer.setUpdateTime(new Timestamp(createTimestamp));

                if (ValidFlag.parse(containerValidFlag) == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[validFlag]");
                }

                tempSysWarehouseContainer.setValidFlag(ValidFlag.parse(containerValidFlag));
                tempSysWarehouseContainer.setControllerCode(controllerCode);
                if (containerLeft != null) {
                    tempSysWarehouseContainer.setCharacterLeft(String.valueOf(containerLeft));
                }

                if (containerRight != null) {
                    tempSysWarehouseContainer.setCharacterRight(String.valueOf(containerRight));
                }

                tempSysWarehouseContainer.setId(IDUtils.uuid());
                sysWarehouseContainerDao.insertSysWarehouseContainer(tempSysWarehouseContainer);
            } else if (containerPlace == 1) {
                SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao.getSysLaboratoryContainerByContainerCode(containerCode);
                if (sysLaboratoryContainer != null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode]");
                }

                SysLaboratory sysLaboratory = sysLaboratoryDao.getSysLaboratoryByBarCode(barCode);
                if (sysLaboratory == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[barCode]");
                }

                Map<String, String> metaMap = new HashMap<>();
                metaMap.put("groupId", "container_type");
                metaMap.put("metaKey", String.valueOf(containerType));

                List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
                if (baseMetaList == null || baseMetaList.size() != 1) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[type]");
                }


                SysLaboratoryContainer tempSysLaboratoryContainer = new SysLaboratoryContainer();
                tempSysLaboratoryContainer.setLaboratoryId(sysLaboratory.getId());
                tempSysLaboratoryContainer.setType(baseMetaList.get(0).getMetaValue());
                tempSysLaboratoryContainer.setContainerCode(containerCode);
                tempSysLaboratoryContainer.setCreateTime(new Timestamp(createTimestamp));
                tempSysLaboratoryContainer.setUpdateTime(new Timestamp(createTimestamp));

                if (ValidFlag.parse(containerValidFlag) == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[validFlag]");
                }

                tempSysLaboratoryContainer.setValidFlag(ValidFlag.parse(containerValidFlag));
                tempSysLaboratoryContainer.setControllerCode(controllerCode);
                if (containerLeft != null) {
                    tempSysLaboratoryContainer.setCharacterLeft(String.valueOf(containerLeft));
                }

                if (containerRight != null) {
                    tempSysLaboratoryContainer.setCharacterRight(String.valueOf(containerRight));
                }
                sysLaboratoryContainer.setId(IDUtils.uuid());
                sysLaboratoryContainerDao.insertSysLaboratoryContainer(sysLaboratoryContainer);
            }
        }



        // 数据保存部分
        // 1. 主控机Code不存在，主控机Code保存到数据字典

        // 2. 将货柜信息保存到DB中
        // 注意：参数货柜位置	place，如果是0 ：仓库        插入sys_warehouse_container表
        //                         如果是1：实验室   插入sys_laboratory_container表
        // containerLeft 对应 DB character_left
        // containerRight 对应 DB character_right
        // createTimestamp 对应 DB create_time

        System.out.println("1111111111111111111111111");
//       注册接口没有之前的关系
//
//        //清除之前的记录，然后关联现在的关系
//        sysWarehouseContainerDao.updateSysWarehouseContainerClearControllerCode(controllerCode);


    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void logoutTestCabinet(String userId, JSONObject jsonObject) throws ApiException {
        if (!jsonObject.containsKey("controllerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerCode]");
        }

        String controllerCode = jsonObject.getString("controllerCode");

        if (controllerCode == null || "".equals(controllerCode.trim())) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[controllerCode]");
        }

        if (!jsonObject.containsKey("containerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerCode]");
        }

        String containerCode = jsonObject.getString("containerCode");
        if (containerCode == null || "".equals(containerCode.trim())) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[controllerCode]");
        }

        if (!jsonObject.containsKey("updateTime")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[updateTime]");
        }

        String updateTime = jsonObject.getString("updateTime");
        if (updateTime == null || "".equals(updateTime.trim())) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[updateTime]");
        }

        SysWarehouseContainer sysWarehouseContainer = sysWarehouseContainerDao.getSysWarehouseContainerByContainerCode(containerCode);

        if (sysWarehouseContainer != null) {
            if (!controllerCode.equals(sysWarehouseContainer.getControllerCode())) {
                throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[controllerCode]");
            } else {
                try {
                    sysWarehouseContainer.setUpdateTime(Timestamp.valueOf(updateTime));
                } catch (Exception e) {
                	e.printStackTrace();
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[updateTime]");
                }
                int count = sysWarehouseContainerDao.invalidSysWarehouseContainer(sysWarehouseContainer);

                if (count == 0) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[updateTime]");
                }
            }
        } else {
            SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao.getSysLaboratoryContainerByContainerCode(containerCode);

            if (sysLaboratoryContainer != null) {
                if (!controllerCode.equals(sysLaboratoryContainer.getControllerCode())) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[controllerCode]");
                } else {
                    try {
                        sysLaboratoryContainer.setUpdateTime(new Timestamp(Long.parseLong(updateTime)));
                    } catch (Exception e) {
                        throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[updateTime]");
                    }

                    int count = sysLaboratoryContainerDao.invalidSysLaboratoryContainer(sysLaboratoryContainer);
                    if (count == 0) {
                        throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[updateTime]");
                    }
                }
            } else {
                throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode]");
            }
        }


        // 根据containerCode更新sys_warehouse_container表或sys_laboratory_container表 的valid_flag字段
        // 根据DB返回的影响数据条数判断是否另一个表是否也要执行，或两个表都执行更新语句都可以。
//        sysWarehouseContainerDao.updateSysWarehouseContainerClearControllerCode(controllerCode);

    }

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void updateTestCabinet(String userId, JSONObject jsonObject) throws ApiException {
        if (!jsonObject.containsKey("updateTime")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[updateTime]");
        }

        String updateTimeStr = jsonObject.getString("updateTime");
        if (updateTimeStr == null || "".equals(updateTimeStr.trim())) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[updateTime]");
        }

        Timestamp updateTime;

        try {
            updateTime = Timestamp.valueOf(updateTimeStr);
        } catch (Exception e) {
            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[updateTime]");
        }

        if (!jsonObject.containsKey("controllerData")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerData]");
        }

        if (!jsonObject.containsKey("containerDataList")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerDataList]");
        }

        JSONObject controllerJson = jsonObject.getJSONObject("controllerData");
        JSONArray containerDataJSONArr = jsonObject.getJSONArray("containerDataList");

        if (!controllerJson.containsKey("controllerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerCode]");
        }

        if (!controllerJson.containsKey("validFlag")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[validFlag]");
        }

        // 数据Check部分
        // 1. 确定主控机Code是否存在
        // 2. 如果主控机Code不存在，抛异常，说主控机Code不存在
        // 注： 货柜Code先不检查了，允许新增+更新混合的情况
        String controllerCode = controllerJson.getString("controllerCode");
        Integer validFlagVal = controllerJson.getInteger("validFlag");

        if (controllerCode == null || "".equals(controllerCode)) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[controllerCode]");
        }

        if (validFlagVal == null) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[validFlag]");
        }

        ValidFlag validFlag = ValidFlag.parse(validFlagVal);

        if (validFlag == null) {
            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[validFlag]");
        }


        SysController sysController = sysControllerDao.getSysControllerByCode(controllerCode);

        if (sysController == null) {
            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[controllerCode]");
        }

//        sysController.setUpdateTime(new Timestamp(updateTime));
        sysController.setUpdateTime(updateTime);
        sysController.setValidFlag(validFlag);
        int count = sysControllerDao.updateSysController(sysController);

//        if (count == 0) {
//            throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[updateTime]");
//        }


        // 数据保存部分
        // 1.循环货柜信息
        //    1.1 根据货柜Code，检查货柜信息是否存在
        // 		1.1.1  如果存在，将货柜信息更新到DB中
        //		1.1.2  如果不存在，将货柜信息保存到DB中
        // 注意：参数货柜位置	place，如果是0 ：仓库        插入sys_warehouse_container表
        //                         如果是1：实验室   插入sys_laboratory_container表
        // containerLeft 对应 DB character_left
        // containerRight 对应 DB character_right
        // createTimestamp 对应 DB create_time

        Iterator<Object> containerDateIterator = containerDataJSONArr.iterator();

        while (containerDateIterator.hasNext()) {
            JSONObject containerDateJson = JSONObject.parseObject(containerDateIterator.next().toString());
            // containerCode
            if (!containerDateJson.containsKey("containerCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerCode]");
            }
            String containerCode = containerDateJson.getString("containerCode");
            if (containerCode == null || "".equals(containerCode.trim())) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[containerCode]");
            }

            // validFlag
            if (!containerDateJson.containsKey("validFlag")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[validFlag]");
            }
            Integer containerValidFlagVal = containerDateJson.getInteger("validFlag");
            if (containerValidFlagVal == null) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "validFlag");
            }
            ValidFlag containerValidFlag = ValidFlag.parse(containerValidFlagVal);
            if (containerValidFlag == null) {
                throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "validFlag");
            }

            // type
            if (!containerDateJson.containsKey("type")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST);
            }
            Integer containerType = containerDateJson.getInteger("type");
            if (containerType == null) {
                throw new ApiException(ApiStatus.PARAM_NULL);
            }

            // place
            if (!containerDateJson.containsKey("place")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST);
            }
            Integer containerPlace = containerDateJson.getInteger("place");
            if (containerPlace == null) {
                throw new ApiException(ApiStatus.PARAM_NULL);
            }

            // barCode
            if (!containerDateJson.containsKey("barCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[barCode]");
            }
            String barCode = containerDateJson.getString("barCode");
            if (barCode == null || "".equals(barCode)) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[barCode]");
            }

            Integer containerLeft = containerDateJson.getInteger("left");
            Integer containerRight = containerDateJson.getInteger("right");
            String containerName = containerDateJson.getString("containerName");

            if (containerPlace == 0) {
                //changku
                SysWarehouseContainer sysWarehouseContainer = sysWarehouseContainerDao.getSysWarehouseContainerByContainerCode(containerCode);

                SysWarehouse sysWarehouse = sysWarehouseDao.getSysWarehouseByBarCode(barCode);
                if (sysWarehouse == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[barCode]");
                }

                Map<String, String> metaMap = new HashMap<>();
                metaMap.put("groupId", "container_type");
                metaMap.put("metaKey", String.valueOf(containerType));

                List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
                if (baseMetaList == null || baseMetaList.size() != 1) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[type]");
                }

                if (sysWarehouseContainer == null) {
                    SysWarehouseContainer tempSysWarehouseContainer = new SysWarehouseContainer();
                    tempSysWarehouseContainer.setId(IDUtils.uuid());
                    tempSysWarehouseContainer.setWarehouseId(sysWarehouse.getId());
//                    tempSysWarehouseContainer.setType(baseMetaList.get(0).getMetaValue());
                    tempSysWarehouseContainer.setType(baseMetaList.get(0).getId());
                    tempSysWarehouseContainer.setName(containerName);
                    tempSysWarehouseContainer.setContainerCode(containerCode);
                    tempSysWarehouseContainer.setCreateTime(updateTime);
                    tempSysWarehouseContainer.setUpdateTime(updateTime);

                    tempSysWarehouseContainer.setValidFlag(containerValidFlag);
                    tempSysWarehouseContainer.setControllerCode(controllerCode);
                    if (containerLeft != null) {
                        tempSysWarehouseContainer.setCharacterLeft(String.valueOf(containerLeft));
                    }

                    if (containerRight != null) {
                        tempSysWarehouseContainer.setCharacterRight(String.valueOf(containerRight));
                    }

                    try {
                        sysWarehouseContainerDao.insertSysWarehouseContainer(tempSysWarehouseContainer);
                    } catch (Exception e) {
                    	e.printStackTrace();
                        throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode insert]");
                    }
                } else {
                    sysWarehouseContainer.setWarehouseId(sysWarehouse.getId());
//                    sysWarehouseContainer.setType(baseMetaList.get(0).getMetaValue());
                    sysWarehouseContainer.setType(baseMetaList.get(0).getId());
                    sysWarehouseContainer.setName(containerName);
                    sysWarehouseContainer.setContainerCode(containerCode);
                    sysWarehouseContainer.setCreateTime(updateTime);
                    sysWarehouseContainer.setUpdateTime(updateTime);

                    sysWarehouseContainer.setValidFlag(containerValidFlag);
                    sysWarehouseContainer.setControllerCode(controllerCode);
                    if (containerLeft != null) {
                        sysWarehouseContainer.setCharacterLeft(String.valueOf(containerLeft));
                    }

                    if (containerRight != null) {
                        sysWarehouseContainer.setCharacterRight(String.valueOf(containerRight));
                    }

                    int containerCount = sysWarehouseContainerDao.updateSysWarehouseContainerForInterface(sysWarehouseContainer);

                    if (containerCount == 0) {
                        throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode updateTime]");
                    }
                }

            } else if (containerPlace == 1) {
                //shiyanshi
                SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao.getSysLaboratoryContainerByContainerCode(containerCode);

                SysLaboratory sysLaboratory = sysLaboratoryDao.getSysLaboratoryByBarCode(barCode);
                if (sysLaboratory == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[barCode]");
                }

                Map<String, String> metaMap = new HashMap<>();
                metaMap.put("groupId", "container_type");
                metaMap.put("metaKey", String.valueOf(containerType));

                List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
                if (baseMetaList == null || baseMetaList.size() != 1) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[type]");
                }

                if (sysLaboratoryContainer == null) {
                    SysLaboratoryContainer tempSysLaboratoryContainer = new SysLaboratoryContainer();
                    tempSysLaboratoryContainer.setId(IDUtils.uuid());
                    tempSysLaboratoryContainer.setLaboratoryId(sysLaboratory.getId());
//                    tempSysLaboratoryContainer.setType(baseMetaList.get(0).getMetaValue());
                    tempSysLaboratoryContainer.setType(baseMetaList.get(0).getId());
                    tempSysLaboratoryContainer.setName(containerName);
                    tempSysLaboratoryContainer.setContainerCode(containerCode);
                    tempSysLaboratoryContainer.setCreateTime(updateTime);
                    tempSysLaboratoryContainer.setUpdateTime(updateTime);

                    tempSysLaboratoryContainer.setValidFlag(containerValidFlag);
                    tempSysLaboratoryContainer.setControllerCode(controllerCode);
                    if (containerLeft != null) {
                        tempSysLaboratoryContainer.setCharacterLeft(String.valueOf(containerLeft));
                    }

                    if (containerRight != null) {
                        tempSysLaboratoryContainer.setCharacterRight(String.valueOf(containerRight));
                    }
                    try {
                        sysLaboratoryContainerDao.insertSysLaboratoryContainer(sysLaboratoryContainer);
                    } catch (Exception e) {
                        throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode insert]");
                    }
                } else {
                    sysLaboratoryContainer.setLaboratoryId(sysLaboratory.getId());
//                    sysLaboratoryContainer.setType(baseMetaList.get(0).getMetaValue());
                    sysLaboratoryContainer.setType(baseMetaList.get(0).getId());
                    sysLaboratoryContainer.setName(containerName);
                    sysLaboratoryContainer.setContainerCode(containerCode);
                    sysLaboratoryContainer.setCreateTime(updateTime);
                    sysLaboratoryContainer.setUpdateTime(updateTime);

                    sysLaboratoryContainer.setValidFlag(containerValidFlag);
                    sysLaboratoryContainer.setControllerCode(controllerCode);
                    if (containerLeft != null) {
                        sysLaboratoryContainer.setCharacterLeft(String.valueOf(containerLeft));
                    }

                    if (containerRight != null) {
                        sysLaboratoryContainer.setCharacterRight(String.valueOf(containerRight));
                    }

                    int containerCount = sysLaboratoryContainerDao.updateSysLaboratoryContainerForInterface(sysLaboratoryContainer);

                    if (containerCount == 0) {
                        throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode updateTime]");
                    }
                }
            }
        }
// 这个不要了
//        List<SysWarehouseContainer> sysWarehouseContainerList = sysWarehouseContainerDao
//                .getSysWarehouseContainerByContainerCodes(containerCodes);
//
//        if (sysWarehouseContainerList.size() != containerCodes.size()) {
//            throw new ApiException(ApiStatus.PARAM_ERR);
//        }
// 这个不要了
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public String openCabinetDoor(String userId, JSONObject jsonObject) throws ApiException {
        if (!jsonObject.containsKey("controllerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[contollerCode]");
        }

        String controllerCode = jsonObject.getString("controllerCode");

        if (controllerCode == null || "".equals(controllerCode)) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[contollerCode]");
        }

        if (!jsonObject.containsKey("containerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerCode]");
        }

        String containerCode = jsonObject.getString("containerCode");

        if (containerCode == null || "".equals(containerCode)) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[containerCode]");
        }

        if (!jsonObject.containsKey("userID")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[userID]");
        }

        String userID = jsonObject.getString("userID");

        if (userID == null || "".equals(userID)) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[userID]");
        }

        if (!jsonObject.containsKey("openTime")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[openTime]");
        }

        String openTime = jsonObject.getString("openTime");

        if (openTime == null || "".equals(openTime)) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[openTime]");
        }
//       参考下面这个sql写
//        <select id="getSysUserInfoList" parameterType="java.util.Map" resultMap="SysUser">
//        select u.name,u.see_flag,u.role_id,u.valid_flag,u.id_card,group_concat(container_code SEPARATOR ',') containerCodeList from sys_user u
//        left join sys_laboratory l on l.department = u.department and l.valid_flag = 1
//        left join sys_laboratory_container c on c.laboratory_id = l.id and c.valid_flag = 1
//        where u.update_time >= #{startTime} and #{endTime} > u.update_time
//        group by u.id;
//      </select>

        SysUser sysUser = sysUserDao.getSysUserInfoByContainerCode(userID, containerCode, controllerCode);



//        JSONObject retJson = new JSONObject();
//
//        retJson.put("code", ApiStatus.OK.getRetCode());
//        retJson.put("message", ApiStatus.OK.getRetMsg());
//        JSONArray jsonArray = new JSONArray();
//        jsonArray.add(sysUser.getRoleId());
//        retJson.put("data", jsonArray);
//        return JSON.toJSONString(retJson);
        if(sysUser!=null){
          // 可以打开柜子
          return "1";
        }else{
          sysUser = sysUserDao.getSysUser(userID);
          // 如果是管理员也可以开柜
          if(sysUser.getSeeFlag() == SeeFlag.MANAGE){
        	  return "1";
          } else {
	          // 不可以打开柜子
	          return "0";
          }
        }
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public List<SysUser> getUserListByContainerCode(String containerCode, String startTime,String endTime) throws ApiException {

        if (containerCode==null||containerCode.isEmpty()) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerCode]");
        }

        List<SysUser> list = sysUserDao.getUserListByContainerCode(containerCode, startTime, endTime);
        return list;
    }

    @Override
    public List<SysUser> getUserListByContainerCodeNew(String containerCode, String startTime, String endTime) throws ApiException{
        if (containerCode==null||containerCode.isEmpty()) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerCode]");
        }
        List<String> projects = sysLaboratoryContainer.selectProjectsByContainerCode(containerCode);
        List<SysUser> userList = null;
        if (projects != null && projects.size() > 0){
            userList = new ArrayList<>();
            for (String project : projects) {
                List<SysUser> dataList = sysUserDao.getUserListByProject(project, startTime, endTime);
                userList.addAll(dataList);
            }
        }
        return userList;
    }


    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void closeCabinetDoor(JSONObject jsonObject) throws ApiException {
        if (!jsonObject.containsKey("controllerCode")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[controllerCode]");
        }

        String controllerCode = jsonObject.getString("controllerCode");

        if (controllerCode == null || "".equals(controllerCode)) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[controllerCode]");
        }


        if (!jsonObject.containsKey("data")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[data]");
        }

        JSONArray dataArr = jsonObject.getJSONArray("data");

        if (dataArr == null) {
            throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[data]");
        }

        Iterator<Object> dataIt = dataArr.iterator();
        while (dataIt.hasNext()) {
            JSONObject dataJson = JSONObject.parseObject(dataIt.next().toString());

            if (!dataJson.containsKey("userID")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[userID]");
            }
            String userId = dataJson.getString("userID");

            if (userId == null || "".equals(userId)) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[userID]");
            }

            if (!dataJson.containsKey("containerCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[containerCode]");
            }

            String containerCode = dataJson.getString("containerCode");
            if (containerCode == null || "".equals(containerCode)) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[containerCode]");
            }

            if (!dataJson.containsKey("closeTime")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[closeTime]");
            }

            String closeTime = dataJson.getString("closeTime");
            if (closeTime == null || "".equals(closeTime)) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[closeTime]");
            }

            if (!dataJson.containsKey("reagentCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[reagentCode]");
            }

            String reagentCode = dataJson.getString("reagentCode");
            if (reagentCode == null || "".equals(reagentCode)) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[reagentCode]");
            }

            if (!dataJson.containsKey("status")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST, ApiStatus.PARAM_NO_EXIST.getRetMsg() + "[status]");
            }

            Integer status = dataJson.getInteger("status");
            if (status == null) {
                throw new ApiException(ApiStatus.PARAM_NULL, ApiStatus.PARAM_NULL.getRetMsg() + "[status]");
            }

            Double weight = dataJson.getDouble("weight");


            OpeReagentStatus queryOpeReagentStatus = opeReagentStatusDao.getOpeReagentStatusByReagentCode(reagentCode);

            if (queryOpeReagentStatus == null) {
                throw new ApiException(ApiStatus.PARAM_ERR);
            }


            SysWarehouseContainer sysWarehouseContainer = sysWarehouseContainerDao.getSysWarehouseContainerByContainerCode(containerCode);
            // 还要到实验室的表里找下


            if (sysWarehouseContainer == null) {

                SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao.getSysLaboratoryContainerByContainerCode(containerCode);

                if (sysLaboratoryContainer == null) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[containerCode]");
                } else {
                    OpeReagentStatus opeReagentStatus = new OpeReagentStatus();
                    opeReagentStatus.setReagentCode(reagentCode);
                    opeReagentStatus.setUserId(userId);
                    opeReagentStatus.setContainerId(sysLaboratoryContainer.getId());
                    opeReagentStatus.setStatus(ArrivalStatus.parse(status));
                    opeReagentStatusDao.updateOpeReagentStatusDao(opeReagentStatus);

                    OpeUseFlow opeUseFlow = new OpeUseFlow();
                    opeUseFlow.setReagentCode(reagentCode);
                    opeUseFlow.setStatus(ArrivalStatus.parse(status));
                    opeUseFlow.setHouseId(queryOpeReagentStatus.getHouseId());
                    opeUseFlow.setContainerId(sysLaboratoryContainer.getId());
                    opeUseFlow.setUserId(userId);
                    if (weight != null){
                    	opeUseFlow.setRemainder(new BigDecimal(weight));
                    }
                    opeUseFlow.setPlace(queryOpeReagentStatus.getPlace());
                    opeUseFlow.setStoreType(queryOpeReagentStatus.getStoreType());
                    opeUseFlow.setValidFlag(queryOpeReagentStatus.getValidFlag());
                    opeUseFlow.setId(IDUtils.uuid());
                    opeUseFlowDao.insertOpeUseFlow(opeUseFlow);
                }

            } else {

                OpeReagentStatus opeReagentStatus = new OpeReagentStatus();
                opeReagentStatus.setReagentCode(reagentCode);
                opeReagentStatus.setUserId(userId);
                opeReagentStatus.setContainerId(sysWarehouseContainer.getId());
                opeReagentStatus.setStatus(ArrivalStatus.parse(status));
                opeReagentStatusDao.updateOpeReagentStatusDao(opeReagentStatus);

                OpeUseFlow opeUseFlow = new OpeUseFlow();
                opeUseFlow.setId(IDUtils.uuid());
                opeUseFlow.setReagentCode(reagentCode);
                opeUseFlow.setStatus(ArrivalStatus.parse(status));
                opeUseFlow.setHouseId(queryOpeReagentStatus.getHouseId());
                opeUseFlow.setContainerId(sysWarehouseContainer.getId());
                opeUseFlow.setUserId(userId);
                opeUseFlow.setRemainder(new BigDecimal(weight));
                opeUseFlow.setPlace(queryOpeReagentStatus.getPlace());
                opeUseFlow.setStoreType(queryOpeReagentStatus.getStoreType());
                opeUseFlow.setValidFlag(queryOpeReagentStatus.getValidFlag());
                opeUseFlowDao.insertOpeUseFlow(opeUseFlow);
            }
        }

    }

    // 将试剂最新信息保存到 ope_reagent_status表
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void synchAllCabinet(JSONArray jsonObject) throws ApiException {
    	Iterator<Object> dataIt = jsonObject.iterator();
    	 while(dataIt.hasNext()) {
    		 JSONObject dataJson = JSONObject.parseObject(dataIt.next().toString());
				// 试剂状态	status	Integer	○
				// 试剂实时状态	realstatus	Integer	○
				// 货柜条码	containerCode	String	○
				// 试剂编号	reagentCode	String	○
				// 用户ID	userID	String
				// 更新时间	updateTime	String	○
				// 残留量	remainder	double
             if (!dataJson.containsKey("status")
                     || !dataJson.containsKey("realstatus")
                     || !dataJson.containsKey("containerCode")
                     || !dataJson.containsKey("reagentCode")
                     || !dataJson.containsKey("updateTime")
            		 ) {
                 throw new ApiException(ApiStatus.PARAM_NO_EXIST);
             }

			Integer status = dataJson.getInteger("status");
			Integer realstatus = dataJson.getInteger("realstatus");
			String containerCode = dataJson.getString("containerCode");
			String reagentCode = dataJson.getString("reagentCode");
			String idcard = dataJson.getString("idcard");
			String updateTime = dataJson.getString("updateTime");
			Double remainder = dataJson.getDouble("remainder");

			SysUser user = sysUserDao.getSysUserByIdCard(idcard);

			LinkedHashMap params = new LinkedHashMap();
			params.put("userId", user.getId());
			params.put("realstatus", realstatus);
			params.put("reagentCode", reagentCode);
			params.put("updateTime", updateTime);
			params.put("remainder", remainder);
			params.put("status", status);

			// <!--0：个人领用 1：在仓库sys_warehouse_container
			// 2：在实验室sys_laboratory_container 3：报废-->
			if (status.equals(1)) {
				/*SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao
						.getSysLaboratoryContainerByContainerCode(containerCode);

				if (Objects.isNull(sysLaboratoryContainer) == false) {
					params.put("containerId", sysLaboratoryContainer.getId());
					params.put("houseId", sysLaboratoryContainer.getLaboratoryId());
				} else {
					logger.error("The containerCode has not been exists!");
					continue;
				}*/
                SysWarehouseContainer container = sysWarehouseContainerDao
                        .getSysWarehouseContainerByContainerCode(containerCode);
                if (Objects.isNull(container) == false) {
                    params.put("containerId", container.getId());
                    params.put("houseId", container.getWarehouseId());
                } else {
                    logger.error("The containerCode has not been exists!");
                    continue;
                }
			}
			else if (status.equals(2)){
				/*SysWarehouseContainer container = sysWarehouseContainerDao
						.getSysWarehouseContainerByContainerCode(containerCode);
				if (Objects.isNull(container) == false) {
					params.put("containerId", container.getId());
					params.put("houseId", container.getWarehouseId());
				} else {
					logger.error("The containerCode has not been exists!");
					continue;
				}*/
                SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao
                        .getSysLaboratoryContainerByContainerCode(containerCode);

                if (Objects.isNull(sysLaboratoryContainer) == false) {
                    params.put("containerId", sysLaboratoryContainer.getId());
                    params.put("houseId", sysLaboratoryContainer.getLaboratoryId());
                } else {
                    logger.error("The containerCode has not been exists!");
                }
			}
			//-1 状态
			if (status.equals(-1)){
                continue;
            }
 			int i = opeReagentStatusDao.syncOpeReagentStatus(params);
            if (i < 1){
                opeReagentStatusDao.syncOpeReagentStatus(params);
            }
    	 }
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void alarm(JSONObject jsonObject) throws ApiException {
        if (!jsonObject.containsKey("controllerCode")
                || ! jsonObject.containsKey("data")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST);
        }

        String controllerCode = jsonObject.getString("controllerCode");
        JSONArray dataArr = jsonObject.getJSONArray("data");

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

        Iterator<Object> dataIt = dataArr.iterator();
        while(dataIt.hasNext()) {
            JSONObject dataJson = JSONObject.parseObject(dataIt.next().toString());

            if (!dataJson.containsKey("warningId")
            		|| !dataJson.containsKey("containerCode")
                    || !dataJson.containsKey("warningTime")
            	) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST);
            }

            String containerCode = dataJson.getString("containerCode");

            //check containerCode是否存在
			SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao
					.getSysLaboratoryContainerByContainerCode(containerCode);
			if (Objects.isNull(sysLaboratoryContainer) == true) {
				SysWarehouseContainer container = sysWarehouseContainerDao
						.getSysWarehouseContainerByContainerCode(containerCode);
				if (Objects.isNull(container) == true) {
					logger.error("The containerCode["+containerCode+"] has not been exists!");
					continue;
				}
			}

            String warningId = dataJson.getString("warningId");

            Map<String, String> metaMap = new HashMap<>();
            metaMap.put("groupId", "alarm_type");
            metaMap.put("metaKey", String.valueOf(warningId));

			List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
			if (baseMetaList == null || baseMetaList.size() != 1) {
				throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[warningId]");
			}

            String warningTimeStr = dataJson.getString("warningTime");
            Integer warningLevelInt = dataJson.getInteger("warningLevel");
            WarningLevel warningLevel = WarningLevel.parse(warningLevelInt);

            SysAlarm sysAlarm = new SysAlarm();
            sysAlarm.setContainerCode(containerCode);
            sysAlarm.setControllerCode(controllerCode);
            sysAlarm.setWarningId(baseMetaList.get(0).getId());
            sysAlarm.setWarningLevel(warningLevel);
            try {
                Date warningTime = sdf.parse(warningTimeStr);
                sysAlarm.setWarningTime(new java.sql.Timestamp(warningTime.getTime()));
            } catch (ParseException e) {
                throw new ApiException(ApiStatus.PARAM_ERR);
            }

            sysAlarmDao.insertSysAlarm(sysAlarm);
//
//            Integer warningPoint = dataJson.getInteger("warningPoint");
//            if(warningPoint == null){
//                warningPoint = 0;
//            }
//            SysUser user = sysUserDao.getSysUser(userId);
//            if(user != null){
//                sysUserDao.updateUserPointBySelective(user.getPoint()-warningPoint,userId);
//            }
        }
    }


    // 人员违规预警接口
    @Override
    public void alarmperson(JSONObject jsonObject) throws Exception {
		JSONArray dataArr = jsonObject.getJSONArray("data");

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

		Iterator<Object> dataIt = dataArr.iterator();
		while (dataIt.hasNext()) {
			JSONObject dataJson = JSONObject.parseObject(dataIt.next().toString());

			// 货柜条码 containerCode String ○
			// 用户 idcard String ○
			// 报警类别 warningId Integer ○
			// 报警时间 warningTime String ○
			// 报警级别 warningLevel Integer ○
			// 扣分 warningPoint Integer ○
			if (!dataJson.containsKey("warningId") || !dataJson.containsKey("containerCode")
					|| !dataJson.containsKey("warningTime") || !dataJson.containsKey("idcard")
					|| !dataJson.containsKey("warningPoint") || !dataJson.containsKey("warningLevel")) {
				throw new ApiException(ApiStatus.PARAM_NO_EXIST);
			}

			String containerCode = dataJson.getString("containerCode");

			String warningId = dataJson.getString("warningId");
			Map<String, String> metaMap = new HashMap<>();
			metaMap.put("groupId", "user_violate_type");
			metaMap.put("metaKey", String.valueOf(warningId));

			List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
			if (baseMetaList == null || baseMetaList.size() != 1) {
				throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[warningId]");
			}


			String warningTimeStr = dataJson.getString("warningTime");
			Integer warningLevelInt = dataJson.getInteger("warningLevel");
			WarningLevel warningLevel = WarningLevel.parse(warningLevelInt);
			String idcard = dataJson.getString("idcard");
			Integer warningPoint = dataJson.getInteger("warningPoint");

			SysUser user = sysUserDao.getSysUserByIdCard(idcard);
			System.out.println("====="+user);
			if(user==null){
			    System.out.println(idcard.length());
                if(idcard.length()==20){
                    idcard=idcard.substring(10,18);
                    user = sysUserDao.getSysUserByIdCard(idcard);
                }
            }

			SysAlarmPerson sysAlarmPerson = new SysAlarmPerson();
			sysAlarmPerson.setContainerCode(containerCode);
			sysAlarmPerson.setWarningId(baseMetaList.get(0).getId());
			sysAlarmPerson.setWarningLevel(warningLevel);
			sysAlarmPerson.setUserId(user.getId());
			sysAlarmPerson.setWarningPoint(warningPoint);
            Timestamp warnTime;
			try {
				Date warningTime = sdf.parse(warningTimeStr);
				//不接收时间超过现在的数据
                if (warningTime.after(new Date())) {
                    throw new  Exception("柜子时间发生错误");
                }
                warnTime = new Timestamp(warningTime.getTime());
                sysAlarmPerson.setWarningTime(warnTime);
			} catch (ParseException e) {
				throw new ApiException(ApiStatus.PARAM_ERR);
			} catch (Exception e) {
                e.printStackTrace();
                throw new Exception(e.getMessage());
            }
            // 将人员违规预警记录保存到数据库表
            int count = sysAlarmPersonDao.repeatedJudgment(containerCode, warningLevelInt, warnTime);
			if (count<1){
			    //获取实验室条码和具体地点
                Map location = sysLaboratoryContainer.selectLocationByContainerCode(containerCode);
                //警告信息
                //具体地点   柜子编码
                String messageFormat = "具体地点:%s,柜号:%s,";
                String content = String.format(messageFormat, location.get("location"), containerCode);
                if ("1".equals(warningId)){
                    content  += "剧毒试剂未称重";
                }else if("2".equals(warningId)){
                    content += "存在相忌试剂混放隐患";
                }else if ("6".equals(warningId)){
                    content += "柜门未关";
                }
                //给daping系统发送信息

                if(!"".equals(alarmUrl) && ("1".equals(warningId) || "2".equals(warningId))){
                    JSONObject json = new JSONObject();
                    json.put("barCode", location.get("barCode"));
                    json.put("type", alarmType);
                    json.put("info", content);
                    json.put("happenTime", warningTimeStr);
                    json.put("dataType", "warn");
                    CloseableHttpClient client2 = HttpClients.createDefault();
                    HttpPost post2 = new HttpPost(alarmUrl);
                    post2.setHeader("Content-Type", "application/json;charset=UTF-8");
                    StringEntity se = new StringEntity(json.toString(), "UTF-8");
                    se.setContentEncoding("UTF-8");
                    se.setContentType("application/json");
                    post2.setEntity(se);
                    CloseableHttpResponse response2 = client2.execute(post2);
                    String resData2 = EntityUtils.toString(response2.getEntity());
                    client2.close();

                    JSONObject data2 = JSONObject.parseObject(resData2);
                    //获取返回的关联Id
                    if ("200".equals(data2.getString("code"))) {
                        JSONObject res = data2.getJSONObject("data");
                        String refId = res.getString("id");
                        if (StringUtils.isNotBlank(refId)) {
                            sysAlarmPerson.setRefId(refId);
                        }
                    } else {
                        //请求错误打印日志
                        logger.info(resData2);
                    }
                }

            if(enable && "2".equals(warningId) ) {
                List<Map> personsInCharge = sysLaboratoryContainer.getContainerPersonInCharge(containerCode);
                Map param = new HashMap();
                param.put("groupId", "securityManager");
                List<BaseMeta> managers = baseMetaDao.getBaseMetaList(param);
                StringBuffer phones = new StringBuffer();

                //实验室负责人手机号
                if (personsInCharge !=null && personsInCharge.size()>0){
                    personsInCharge.forEach(person -> {
                        Object phone = person.get("phone");
                        if (phone != null && !"".equals(phone)) {
                            phones.append(phone);
                            phones.append(",");
                        }

                    });
                }
                //所及负责人手机号
                if (managers !=null && managers.size() >0){
                    managers.forEach(manager -> {
                        String phone = manager.getMetaValue();
                        if (phone != null && !"".equals(phone)) {
                            phones.append(phone);
                            phones.append(",");
                        }
                    });
                }
                if (phones.length() >0){
                    phones.deleteCharAt(phones.length() - 1);

                }

                String suffix = String.format("?head=%s&signature=%s&content=%s&telnumber=%s", head, signature, content, phones.toString().replace(" ", ""));
                CloseableHttpClient client = HttpClients.createDefault();
                HttpPost post = new HttpPost(url + suffix);
                post.setHeader("Content-Type", "application/json;charset=UTF-8");
                CloseableHttpResponse response = client.execute(post);
                String resData = EntityUtils.toString(response.getEntity(),"UTF-8");
                client.close();
                JSONObject res = JSONObject.parseObject(resData);
                if ("200".equals(res.getString("code")) && phones.length() >0){
                    String memo = String.format("短信已发送[%s]", phones);
                    sysAlarmPerson.setMemo(memo);
                }
                logger.info(resData);

            }
                sysAlarmPersonDao.insertSysAlarmPerson(sysAlarmPerson);
                // 将人员扣分更新到人员表
                if (warningPoint == null) {
                    warningPoint = 0;
                }
                 //	SysUser user = sysUserDao.getSysUser(userId);
                if (user != null) {
                    sysUserDao.updateUserPointBySelective(user.getPoint() - warningPoint, user.getId());
                }
			}


		}
    }

    // 人员违规预警接口
    /*@Override
	public void alarmperson(JSONObject jsonObject) throws ApiException {
		// TODO Auto-generated method stub
    	if (!jsonObject.containsKey("controllerCode")
                || ! jsonObject.containsKey("data")) {
            throw new ApiException(ApiStatus.PARAM_NO_EXIST);
        }

        String controllerCode = jsonObject.getString("controllerCode");
        JSONArray dataArr = jsonObject.getJSONArray("data");

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

        Iterator<Object> dataIt = dataArr.iterator();
        while(dataIt.hasNext()) {
            JSONObject dataJson = JSONObject.parseObject(dataIt.next().toString());

            if (!dataJson.containsKey("warningId")
                    || !dataJson.containsKey("userId")
                    || !dataJson.containsKey("warningTime")
                    || !dataJson.containsKey("warningLevel")
                    || !dataJson.containsKey("warningPoint")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST);
            }

            String containerCode = dataJson.getString("containerCode");
            String warningId = dataJson.getString("warningId");
            String userId = dataJson.getString("userId");
            String warningTimeStr = dataJson.getString("warningTime");
            Integer warningLevelInt = dataJson.getInteger("warningLevel");
            Integer warningPoint = dataJson.getInteger("warningPoint");
            WarningLevel warningLevel = WarningLevel.parse(warningLevelInt);

            SysAlarmPerson sysAlarmPerson = new SysAlarmPerson();
            sysAlarmPerson.setContainerCode(containerCode);
            sysAlarmPerson.setControllerCode(controllerCode);
            sysAlarmPerson.setWarningId(warningId);
            sysAlarmPerson.setWarningLevel(warningLevel);
            sysAlarmPerson.setUserId(userId);
            sysAlarmPerson.setWarningPoint(warningPoint);

            try {
                Date warningTime = sdf.parse(warningTimeStr);
                sysAlarm.setWarningTime(new java.sql.Timestamp(warningTime.getTime()));
            } catch (ParseException e) {
                throw new ApiException(ApiStatus.PARAM_ERR);
            }

            sysAlarmDao.insertSysAlarm(sysAlarm);
        }
	}*/

	@Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void cabinetData(JSONArray jsonObject) throws ApiException {

    	Iterator<Object> dataIt = jsonObject.iterator();
    	 while(dataIt.hasNext()) {
    		 JSONObject dataJson = JSONObject.parseObject(dataIt.next().toString());
			//    		 试剂状态	status	Integer	○
			//    		 试剂实时状态	realstatus	Integer	○
			//    		 用户ID	userId	String	○
			//    		 试剂编号	reagentCode	String	○
			//    		 更新时间	updateTime	String	○
			//    		 货柜条码	containerCode	String
			//    		 残留量	remainder	double
			//    		 操作状态	operateState	Integer	○
    		 // 非空检查
             if (!dataJson.containsKey("status")
                     || !dataJson.containsKey("realstatus")
                     || !dataJson.containsKey("containerCode")
                     || !dataJson.containsKey("reagentCode")
                     || !dataJson.containsKey("updateTime")
                     || !dataJson.containsKey("operateState")
            		 ) {
                 throw new ApiException(ApiStatus.PARAM_NO_EXIST);
             }

			Integer status = dataJson.getInteger("status");
			Integer realstatus = dataJson.getInteger("realstatus");
			String containerCode = dataJson.getString("containerCode");
			String reagentCode = dataJson.getString("reagentCode");
			String idcard = dataJson.getString("idcard");
			String updateTime = dataJson.getString("updateTime");
			BigDecimal remainder = dataJson.getBigDecimal("remainder");
			String operateState = dataJson.getString("operateState");

			Map<String, String> metaMap = new HashMap<>();
            metaMap.put("groupId", "operate_status");
            metaMap.put("metaKey", String.valueOf(operateState));
            List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);

			Date createtime = null;
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			try {
				 createtime = sdf.parse(updateTime);
			} catch (ParseException e) {
				throw new ApiException(ApiStatus.PARAM_ERR);
			}

			SysUser user = sysUserDao.getSysUserByIdCard(idcard);

			if (user == null || user.getIdCard() == null) {
				throw new ApiException(ApiStatus.PARAM_ERR, "idcard: "+idcard);
			}

			OpeUseFlow opeUseFlow = new OpeUseFlow();
			opeUseFlow.setReagentCode(reagentCode);
			opeUseFlow.setUserId(user.getId());
			opeUseFlow.setRemainder(remainder);
			opeUseFlow.setOperateState(baseMetaList.get(0).getId());
			opeUseFlow.setCreateTime(new java.sql.Timestamp(createtime.getTime()));

			// <!--0：个人领用 1：在仓库sys_warehouse_container
			// 2：在实验室sys_laboratory_container 3：报废-->



//			if (status.equals(1)) {
//				SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao
//						.getSysLaboratoryContainerByContainerCode(containerCode);
//
//				if (Objects.isNull(sysLaboratoryContainer) == false) {
//					opeUseFlow.setStatus(ArrivalStatus.LABORATORY);
////					opeUseFlow.setPlace(status.toString());
//					opeUseFlow.setContainerId(sysLaboratoryContainer.getId());
//					opeUseFlow.setHouseId(sysLaboratoryContainer.getLaboratoryId());
//				} else {
//					logger.error("The containerCode has not been exists!");
//					continue;
//				}
//			} else if (status.equals(2)){
//				SysWarehouseContainer container = sysWarehouseContainerDao
//						.getSysWarehouseContainerByContainerCode(containerCode);
//				if (Objects.isNull(container) == false) {
//					opeUseFlow.setStatus(ArrivalStatus.WAREHOUSE);
////					opeUseFlow.setPlace(status.toString());
//					opeUseFlow.setContainerId(container.getId());
//					opeUseFlow.setHouseId(container.getWarehouseId());
//
//				} else {
//					logger.error("The containerCode has not been exists!");
//					continue;
//				}
//			}

			opeUseFlow.setStatus(ArrivalStatus.parse(Integer.valueOf(String.valueOf(dataJson.get("status")))));
			SysLaboratoryContainer sysLaboratoryContainer = sysLaboratoryContainerDao
					.getSysLaboratoryContainerByContainerCode(containerCode);

			if (Objects.isNull(sysLaboratoryContainer) == false) {
				opeUseFlow.setContainerId(sysLaboratoryContainer.getId());
				opeUseFlow.setHouseId(sysLaboratoryContainer.getLaboratoryId());
			} else {
				SysWarehouseContainer container = sysWarehouseContainerDao
						.getSysWarehouseContainerByContainerCode(containerCode);
				if (Objects.isNull(container) == false) {

					opeUseFlow.setContainerId(container.getId());
					opeUseFlow.setHouseId(container.getWarehouseId());

				} else {
					logger.error("The containerCode has not been exists!");
					continue;
				}
			}
             int count = opeUseFlowService.getOpeUseFlow(opeUseFlow);
             if (count < 1) {

                 this.opeUseFlowService.insertOpeUseFlow(opeUseFlow);
             }
    	 }
    }

    @Override
    public JSONObject getContainerInfo(JSONObject jsonObject) {
        return null;
    }

    @Override
    public JSONObject getReagentInfo(JSONObject jsonObject) {
        return null;
    }

    @Override
    public JSONObject getUserInfo(JSONObject jsonObject) {
        return null;
    }

    // 人员违规预警接口
    @Override
    public void delalarmperson(JSONObject jsonObject) throws Exception {
        JSONArray dataArr = jsonObject.getJSONArray("data");
        Iterator<Object> dataIt = dataArr.iterator();
        while (dataIt.hasNext()) {
            JSONObject dataJson = JSONObject.parseObject(dataIt.next().toString());
            // 货柜条码 containerCode String ○
            // 报警类别 warningId Integer ○
            if (!dataJson.containsKey("warningId") || !dataJson.containsKey("containerCode")) {
                throw new ApiException(ApiStatus.PARAM_NO_EXIST);
            }
            String containerCode = dataJson.getString("containerCode");
            String warningId = dataJson.getString("warningId");
            List<String> warningList = Arrays.asList(warningId.split(","));
            List<String> warningList1 = new ArrayList<>(Arrays.asList("1","2","3","4","5","6"));
            List<String> delWarnings = warningList1.stream().filter(o->!warningList.contains(o)).collect(Collectors.toList());//新的不在原有里面的

            for (String warning : delWarnings){
                Map<String, String> metaMap = new HashMap<>();
                metaMap.put("groupId", "user_violate_type");
                metaMap.put("metaKey", warning);

                List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
                if (baseMetaList == null || baseMetaList.size() != 1) {
                    throw new ApiException(ApiStatus.PARAM_ERR, ApiStatus.PARAM_ERR.getRetMsg() + "[warningId]");
                }
                SysAlarmPerson sysAlarmPerson = new SysAlarmPerson();
                sysAlarmPerson.setContainerCode(containerCode);
                sysAlarmPerson.setWarningId(baseMetaList.get(0).getId());
                List<SysAlarmPerson> sysAlarmPersonList = sysAlarmPersonDao.selectByCode(containerCode, baseMetaList.get(0).getId());
                for (SysAlarmPerson sysAlarm : sysAlarmPersonList) {
                    if (!"".equals(alarmUrl) && StringUtils.isNotBlank(sysAlarm.getRefId()) && ("1".equals(warning) || "2".equals(warning))) {
                        SysWarning sysWarning = new SysWarning();
                        sysWarning.setId(String.valueOf(sysAlarm.getId()));
                        sysWarning.setStatus(1);
                        sysWarning.setAlarmId(sysAlarm.getRefId());
                        sysWarningService.updateSysWarning(sysWarning);
                    }else {
                        Map<String,Object> params = new HashMap<>();
                        params.put("status",1);
                        params.put("id", String.valueOf(sysAlarm.getId()));
                        sysWarningDao.updateSysWarning(params);
                    }
                }
            }
        }
    }
}