depot-basic-tianjin/src/main/java/com/chinaitop/depot/basic/controller/BasicStorehouseController.java

package com.chinaitop.depot.basic.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import com.alibaba.fastjson.JSONObject;
import com.chinaitop.depot.basic.model.BasicEnum;
import com.chinaitop.depot.basic.model.BasicKeeper;
import com.chinaitop.depot.basic.model.BasicKeeperExample;
import com.chinaitop.depot.basic.model.BasicKeeperHouse;
import com.chinaitop.depot.basic.model.BasicKeeperHouseExample;
import com.chinaitop.depot.basic.model.BasicStorehouse;
import com.chinaitop.depot.basic.model.BasicStorehouseExample;
import com.chinaitop.depot.basic.model.BasicStorehouseExample.Criteria;
import com.chinaitop.depot.basic.service.BasicEnumService;
import com.chinaitop.depot.basic.service.BasicKeeperHouseService;
import com.chinaitop.depot.basic.service.BasicKeeperService;
import com.chinaitop.depot.basic.service.BasicStorehouseService;
import com.chinaitop.depot.basic.service.BasicWarehouseService;
import com.chinaitop.depot.common.service.ImportServiceImpl;
import com.chinaitop.utils.ParameterUtil;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;

/**
 * 仓房管理Controller，仓房管理菜单中所有的功能都在这里
 *
 * @author User
 *
 */
@SuppressWarnings("all")
@RestController
@RequestMapping(value = "/Storehouse")
@Api(value= "BasicStorehouseController", description = "仓房管理控制类")
public class BasicStorehouseController {

	final static Logger logger = LoggerFactory.getLogger(BasicStorehouse.class);
	@Resource
	private BasicStorehouseService basicStorehouseService;
	@Resource
	private BasicWarehouseService basicWarehouseService;
	@Resource
	private BasicEnumService enumService;
	@Resource
	private BasicKeeperHouseService keeperHouseService;
	@Resource
	private BasicKeeperService keeperService;
	@Resource
	private ImportServiceImpl importService;

	@Value("${web.upload-path}")
	private String uploadPath;

	/**
	 * 查找仓房信息
	 *
	 * @param pageNum 页数
	 * @param pageSize 每页显示的条数
	 * @param storeName 仓房名称
	 * @param houseId 仓房ID
	 * @param orgId 单位ID
	 * @param storehouseState 仓房状态
	 * @param libraryType 粮库类型
	 * @return
	 */
	@RequestMapping(value = "/getList", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="查询仓房信息数据列表", notes = "查询仓房信息数据列表，支持分页")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "pageNum", value = "页码", paramType = "query"),
			@ApiImplicitParam(name = "pageSize", value = "每页条数", paramType = "query"),
			@ApiImplicitParam(name = "storeName", value = "仓房名称", paramType = "query"),
			@ApiImplicitParam(name = "houseId", value = "仓房ID", paramType = "query"),
			@ApiImplicitParam(name = "orgId", value = "单位ID", paramType = "query"),
			@ApiImplicitParam(name = "storehouseState", value = "仓房状态", paramType = "query"),
			@ApiImplicitParam(name = "storehouseType", value = "仓房类型", paramType = "query"),
			@ApiImplicitParam(name = "libraryType", value = "粮库类型", paramType = "query"),
			@ApiImplicitParam(name = "delFlag", value = "是否删除", paramType = "query")
	})
	public PageInfo<BasicStorehouse> getList(Integer pageNum, Integer pageSize, Integer storehouseType,
											 String storeName, Integer houseId, Integer orgId, Integer storehouseState, 
											 String libraryType, Integer delFlag) {
		Map<String, Object> modelMap = new HashMap<String, Object>();
		if (pageNum != null && pageSize != null) {
			PageHelper.startPage(pageNum, pageSize);
		}
		List<BasicStorehouse> list = null;
		try {
			if (null != storehouseType) {
				modelMap.put("storehouseType",storehouseType);
			}
			if (null != storeName && !"".equals(storeName)) {
				modelMap.put("storehouseName",storeName);
			}
			if (null != houseId) {
				modelMap.put("storehouseId",houseId);
			}
			if (null != storehouseState) {
				modelMap.put("storehouseState",storehouseState);
			}
			if (null != libraryType) {
				modelMap.put("libraryType",libraryType);
			}

			/* 只能查询当前单位的数据  */
			if (null != orgId) {
				modelMap.put("orgId",orgId);
			}

			// 值为1是没删除的数据(在用),0是已删除的数据(弃用)
			if (null != delFlag) {
				modelMap.put("delFlag",delFlag);
			}

			// 查询仓房，不要油罐
			modelMap.put("datatype", "0");
			list = basicStorehouseService.findBasicStorehouseNew(modelMap);
			//获取当前仓房的保管员
			if (null != list && list.size() > 0 && ParameterUtil.isequal("0",libraryType)) {
				String keeperNames = "";
				for (BasicStorehouse storehouse : list) {
					keeperNames = basicStorehouseService.getKeeperNames(storehouse.getStorehouseId());
					storehouse.setDutystoreman(keeperNames);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		PageInfo<BasicStorehouse> pageInfo = new PageInfo<BasicStorehouse>(list);
		return pageInfo;
	}

	/**
	 * 根据ID查找仓房信息
	 *
	 * @param id 数据ID
	 * @return
	 */
	@RequestMapping(value = "/findByStorehouse", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="根据ID查找仓房信息", notes = "根据ID查找仓房信息")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "id", value = "数据ID", paramType = "query"),
			@ApiImplicitParam(name = "orgId", value = "单位ID", paramType = "query")
	})
	public BasicStorehouse findByStorehouse(Integer id, Integer orgId) {
		BasicStorehouse basicStorehouse = null;
		try {
			if (id != null) {
				basicStorehouse = basicStorehouseService.findByPrimary(id);
				if(ParameterUtil.isequal(basicStorehouse.getLibraryType(),"0")){
					//获取当前仓房的保管员
					String keeperNames = basicStorehouseService.getStorehouseKeeper(id, orgId, false);
					basicStorehouse.setDutystoreman(keeperNames);
				}
			} else {
				basicStorehouse = new BasicStorehouse();
			}

		} catch (Exception e) {
			e.printStackTrace();
		}
		return basicStorehouse;
	}

	/**
	 * 根据单位查找单位下的所有仓房信息(统一对外接口)
	 *
	 * @param unitId 单位ID
	 * @return
	 */
	@RequestMapping(value = "/getStorehouseList", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="根据单位查找单位下的所有仓房信息(统一对外接口)", notes = "根据单位查找单位下的所有仓房信息(统一对外接口)")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "unitId", value = "单位ID", paramType = "query"),
			@ApiImplicitParam(name = "libraryType", value = "仓房性质(主粮库或代储点)", paramType = "query")
	})
	public Map<String, Object> getStorehouseList(Integer unitId, String libraryType) {
		Map<String, Object> map = null;
		try {
			map = basicStorehouseService.getStorehouseData(unitId, libraryType);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return map;
	}

	@RequestMapping(value = "/edit", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.POST)
	@ApiOperation(value="更新仓房信息", notes = "更新仓房信息")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "storehouseJson", value = "JSON数据对象", paramType = "form"),
			@ApiImplicitParam(name = "warehouseJson", value = "货位数据", paramType = "form"),
			@ApiImplicitParam(name = "userInfo", value = "JSON登录对象", paramType = "form")
	})
	public Map<String, Object> edit(HttpServletRequest request, String storehouseJson, String warehouseJson, String userInfo) {
		Map<String, Object> modelMap = null;
		try {
			modelMap = basicStorehouseService.saveOrUpdate(request, storehouseJson, warehouseJson, userInfo);
		} catch (Exception e) {
			e.printStackTrace();
			modelMap.put("status", "error");
			modelMap.put("msg", "保存失败！");
		} finally {
			return modelMap;
		}
	}

	/**
	 * 按仓房ID逻辑删除仓房信息
	 *
	 * @param id 数据ID
	 * @return
	 */
	@RequestMapping(value = "/remove", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.POST)
	@ApiOperation(value="按仓房ID逻辑删除仓房信息", notes = "按仓房ID逻辑删除仓房信息")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "id", value = "数据ID", paramType = "form")
	})
	public Map<String, Object> remove(Integer id) {
		Map<String, Object> modelMap = new HashMap<String, Object>();
		try {
			// 先查询到这条数据
			BasicStorehouse basicStorehouse = basicStorehouseService.findByPrimary(id);

			// 如果当前是在用，则改成0，如果当前是弃用则改成1
			Integer delFlag = basicStorehouse.getDelFlag();
			if (delFlag == 1 || "1".equals(delFlag)) {
				delFlag = 0;
			} else if (delFlag == 0 || "0".equals(delFlag)) {
				delFlag = 1;
			}
			basicStorehouse.setDelFlag(delFlag);
			basicStorehouseService.updateBasicStorehouse(basicStorehouse);
			/* 更新单位表中仓房数、油罐数、有效仓容、有效罐容 */
			basicStorehouseService.editOrgChNum(basicStorehouse.getOrgId());
			/* 同时删除这个仓房下的货位信息 */
			/*basicWarehouseService.deletEexample(basicStorehouse.getStorehouseId());*/
			modelMap.put("status", "success");
		} catch (Exception e) {
			e.printStackTrace();
			modelMap.put("status", "error");
			modelMap.put("msg", "操作失败！");
		}
		return modelMap;
	}

	/**
	 * 根据登录人角色不同显示不同仓房列表
	 * @param pageNum
	 * @param pageSize
	 * @return
	 */
	@RequestMapping(value = "/findStoreHouseListByRole", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="根据登录人角色不同显示不同仓房列表", notes = "根据登录人角色不同显示不同仓房列表")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "pageNum", value = "页码", paramType = "query"),
			@ApiImplicitParam(name = "pageSize", value = "每页条数", paramType = "query"),
			@ApiImplicitParam(name = "houseNo", value = "仓房ID", paramType = "query"),
			@ApiImplicitParam(name = "userInfo", value = "登录人数据对象JSON", paramType = "query"),
			@ApiImplicitParam(name = "userRoleList", value = "登录人角色数据JSON", paramType = "query")
	})
	public PageInfo<BasicStorehouse> findStoreHouseList(Integer pageNum, Integer pageSize, Integer houseNo, String userInfo, String userRoleList) {
		//得到当前登录人id
		JSONObject user = null;
		Integer orgId = null;
		Integer userId = null;
		if (null != userInfo && !"".equals(userInfo)) {
			user = JSONObject.parseObject(userInfo);
			orgId = Integer.parseInt(user.get("orgId") == null?"":user.get("orgId").toString());
			userId = Integer.parseInt(user.get("userId") == null?"":user.get("userId").toString());
		}

		//取出仓储科科长，保管员角色的id    词典5417  词典5418
		//①保管员角色编号5417  找到枚举编码就是对应保管员角色的id
		BasicEnum basicEnum=null;
		String wareDpt=null;
		try {
			//取出仓储科科长
			basicEnum = enumService.findByParmeryKeyEnum(5418);
			wareDpt = basicEnum.getEnumcode();//仓储科长角色对应的枚举编码
		} catch (Exception e) {
			e.printStackTrace();
		}

		BasicStorehouseExample storehouseExample = new BasicStorehouseExample();
		BasicStorehouseExample.Criteria Cria = storehouseExample.createCriteria();
		List<BasicStorehouse> list = null;
		try {
			Cria.andDelFlagEqualTo(1); // 查询正常数据
			if (null != orgId && !"".equals(orgId)) {
				Cria.andOrgIdEqualTo(orgId);
			}
			//根据保管员id和仓储科id判断当前登录人属于这两中角色的什么角色
			//①登录人包含仓储科角色(查询出所有的仓房)
			if(userRoleList.contains(wareDpt)){
				list = basicStorehouseService.findBasicStorehouse(storehouseExample);
			} else {
				//②登录人包含保管员角色(查询出自己管理的仓房)
				BasicKeeperExample keeperExample = new BasicKeeperExample();
				BasicKeeperExample.Criteria keeperCriteria=keeperExample.createCriteria();
				if (null != userId && !"".equals(userId)) {
					keeperCriteria.andUserIdEqualTo(userId);
				}
				//查询未删除的标记'删除状态(1.正常，0.删除)'
				keeperCriteria.andDelFlagEqualTo(1);
				List<BasicKeeper> keeperList = keeperService.findCondition(keeperExample);
				if(keeperList.size()>0 && keeperList != null){
					BasicKeeperHouseExample keeperHouseExample = new BasicKeeperHouseExample();
					BasicKeeperHouseExample.Criteria Criteria=keeperHouseExample.createCriteria();
					Criteria.andKeeperIdEqualTo(Integer.valueOf(keeperList.get(0).getId()));
					if (null != orgId && !"".equals(orgId)) {
						Criteria.andOrgIdEqualTo(orgId);
					}
					//2.1查询出该保管员管理的哪些仓房
					List<BasicKeeperHouse> keeperHouseList = keeperHouseService.findCondition(keeperHouseExample);
					List<Integer> houseIdList = new ArrayList<Integer>();
					if(keeperHouseList.size()>0 && keeperHouseList != null){
						for (BasicKeeperHouse be : keeperHouseList) {
							Integer houseId=be.getHouseId();
							houseIdList.add(houseId);
						}
						//前台传过来houseId 说明是按照仓房编号查询的筛选条件  否则是查询所有的保管员所管理的仓
						if(houseNo !=null && houseIdList.contains(houseNo) ){
							houseIdList.clear();//先清空list里面的仓  添加查询的仓
							houseIdList.add(houseNo);
						}else if(houseNo !=null && !houseIdList.contains(houseNo)){
							houseIdList.clear();//先清空list里面的仓  添加查询的仓
							houseIdList.add(0);//这里随便写的数字  为了防止按条件查询到不想要的数据
						}
					}

					if (pageNum != null && pageSize != null) {
						PageHelper.startPage(pageNum, pageSize);
					}

					//2.2取出这些仓房信息
					if(houseIdList.size()>0 && houseIdList != null){
						Cria.andStorehouseIdIn(houseIdList);
					}else{
						houseIdList.add(0);//这里随便写的数字  为了防止按条件查询到不想要的数据
						Cria.andStorehouseIdIn(houseIdList);
					}

					list = basicStorehouseService.findBasicStorehouse(storehouseExample);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}

		PageInfo<BasicStorehouse> pageInfo = new PageInfo<BasicStorehouse>(list);
		return pageInfo;
	}

	/**
	 *  查询当前登录人用户的角色为保管员 所管理的仓房
	 */
	@RequestMapping(value = "/findStoreHouseListByLoginUser", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="查询当前登录人用户的角色为保管员 所管理的仓房", notes = "查询当前登录人用户的角色为保管员 所管理的仓房")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "userInfo", value = "登录人数据对象JSON", paramType = "query")
	})
	public List<BasicStorehouse> findStoreHouseListByLoginUser(String userInfo) {
		JSONObject user = null;
		Integer orgId = null;
		Integer userId = null;
		if (null != userInfo && !"".equals(userInfo)) {
			user = JSONObject.parseObject(userInfo);
			orgId = Integer.parseInt(user.get("orgId") == null?"":user.get("orgId").toString());
			userId = Integer.parseInt(user.get("userId") == null?"":user.get("userId").toString());
		}
		BasicKeeperExample keeperExample = new BasicKeeperExample();
		BasicKeeperExample.Criteria keeperCriteria=keeperExample.createCriteria();

		List<BasicStorehouse> storehouseList=new ArrayList<BasicStorehouse>();
		try {
			//5417保管员角色编号Id  enumCode对应的就是保管员的id
			//basicEnum = enumService.findByParmeryKeyEnum(5417);
			//keeperId=basicEnum.getEnumcode();//保管员角色对应的id
			//查询当前正常用户的角色为保管员
			keeperCriteria.andUserIdEqualTo(userId);
			keeperCriteria.andDelFlagEqualTo(1);
			//keeperCriteria.andPostTypeEqualTo(Integer.valueOf(keeperId));
			List<BasicKeeper> keeperList = keeperService.findCondition(keeperExample);
			if(keeperList.size()>0 && keeperList != null){
				BasicKeeperHouseExample keeperHouseExample = new BasicKeeperHouseExample();
				BasicKeeperHouseExample.Criteria Criteria=keeperHouseExample.createCriteria();
				Criteria.andKeeperIdEqualTo(Integer.valueOf(keeperList.get(0).getId()));
				Criteria.andOrgIdEqualTo(orgId);
				//2.1查询出该保管员管理的哪些仓房
				List<BasicKeeperHouse> keeperHouseList = keeperHouseService.findCondition(keeperHouseExample);

				BasicStorehouseExample example = new BasicStorehouseExample();
				Criteria Cri = example.createCriteria();

				BasicStorehouse basicStorehouse=null;
				for (BasicKeeperHouse be : keeperHouseList) {
					Integer houseId=be.getHouseId();
					Cri.andStorehouseIdEqualTo(houseId);
					try{
						//2.2根据仓房id查询对应的仓房信息
						basicStorehouse = basicStorehouseService.findByPrimary(houseId);
						storehouseList.add(basicStorehouse);
					}catch (Exception ex){
						ex.printStackTrace();
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return storehouseList;
	}

	/**
	 * 导入excel
	 * @param file 文件
	 * @param fileType 类型：如xlsx
	 * @param request
	 * @return
	 */
	@RequestMapping(value="/importFile", method=RequestMethod.POST)
	@ApiOperation(value="导入仓房货位excel", notes = "导入仓房货位excel")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "file", value = "文件数据", paramType = "form"),
			@ApiImplicitParam(name = "fileType", value = "文件名称", paramType = "form"),
			@ApiImplicitParam(name = "userInfo", value = "JSON登录对象", paramType = "form"),
	})
	public String importFile(MultipartFile file, String fileType, String userInfo, HttpServletRequest request){

		JSONObject user = null;
		if (null != userInfo && !"".equals(userInfo)) {
			user = JSONObject.parseObject(userInfo);
		}

		String[] titleArr = {"仓房编号", "仓房名称", "仓房类型", "设计仓容(吨)", "实际仓容(吨)","通风方式", "保管方式", "装粮线高度(m)",
				 "仓房状态","交付使用日期", "货位编号", "货位名称", "货位容量(吨)","粮库类型(代储点是1,正式粮库是0)","代储点粮库名称"};//第一行的title
		boolean[] emptyArr = {false, false, false, true, false, false, false, true, false, true, true, true, true, false, true};//指定列可为空，不可为空值为false.

		List<List<String>> list = new ArrayList<List<String>>();//该list为数据返回的list
		String errormsg = null;
		try {
			errormsg = importService.importFile(uploadPath, file, fileType, request, titleArr, emptyArr, list);

			if (errormsg != null && !"".equals(errormsg)) {
				return errormsg;
			}

			if (list.size()>0) {
				errormsg = basicStorehouseService.importData(list, user);

				System.out.println(list);
				System.out.println(errormsg);
				//errormsg = "导入成功！";
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return errormsg;
	}

	/**
	 * 按仓房编码进行查询，去重
	 * @param storehouseCode 仓房编码
	 */
	@RequestMapping(value="/findStoreCode", method=RequestMethod.GET)
	@ApiOperation(value="防止仓房编码重复添加", notes = "storehouseCode参数")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "storehouseCode", value = "仓房编码", paramType = "query"),
			@ApiImplicitParam(name = "storeId", value = "仓房ID", paramType = "form"),
			@ApiImplicitParam(name = "libraryType", value = "判断是代储点还是主库", paramType = "form")
			})
	public String findStoreCode(HttpServletRequest request, String storehouseCode, Integer storeId, String libraryType) {
		String codeFlag = "";
		List<BasicStorehouse> list = null;
		Integer orgId = (Integer) request.getSession().getAttribute("orgId");
		BasicStorehouseExample storehouseExample = new BasicStorehouseExample();
		BasicStorehouseExample.Criteria cria = storehouseExample.createCriteria();
		cria.andOrgIdEqualTo(orgId);
		cria.andStorehouseIdNotEqualTo(storeId);
		//cria.andLibraryTypeEqualTo(libraryType);
		cria.andStorehouseCodeEqualTo(storehouseCode);
		try {
			list = basicStorehouseService.findBasicStorehouse(storehouseExample);
			if (null != list && list.size() > 0) {
				codeFlag = "0";
			} else {
				codeFlag = "1";
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return codeFlag;
	}

	/**
	 * 查询代储库下边的仓房信息
	 *
	 * @param depotId 单位ID
	 * @return
	 */
	@RequestMapping(value = "/getAgentList", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="查询代储库仓房", notes = "查询代储库下边的仓房信息")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "depotId", value = "代储库ID", paramType = "query"),
			@ApiImplicitParam(name = "orgId", value = "单位ID", paramType = "query"),
			@ApiImplicitParam(name = "libraryType", value = "粮库类型", paramType = "query"),
	})
	public List<BasicStorehouse> getAgentList(Integer depotId,Integer orgId,String libraryType) {
		BasicStorehouseExample example = new BasicStorehouseExample();
		Criteria Criteria = example.createCriteria();
		List<BasicStorehouse> list = null;
		try {
			Criteria.andDepotIdEqualTo(depotId);
			Criteria.andDelFlagEqualTo(1);
			Criteria.andLibraryTypeEqualTo(libraryType);
			if (null != orgId) {
				Criteria.andOrgIdEqualTo(orgId);
			}

			example.setOrderByClause(" storehouse_id asc");
			list = basicStorehouseService.findBasicStorehouse(example);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;
	}
	
	/**
	 * 查询三温检查列表最新数据所对应的仓房
	 * 
	 * @param orgId 粮库ID
	 * @return
	 */
	@RequestMapping(value = "/getThreeTempCheckList", produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="根据单位查找单位下的所有仓房信息(统一对外接口)", notes = "根据单位查找单位下的所有仓房信息(统一对外接口)")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "orgId", value = "粮库ID", paramType = "query")
	})
	public Map<String, Object> getThreeTempCheckList(Integer orgId) throws Exception {
		Map<String, Object> map = null;
		map = basicStorehouseService.getThreeTempCheckList(orgId);
		return map;
	}


    /**
     * 根据仓房ID获取仓房name
     */
    @RequestMapping(value="/getStoreDataByHouseId",produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
    @ApiOperation(value="根据仓房ID获取仓房name", notes = "根据仓房ID获取仓房name")
    public Map<String, Object> getStoreDataByHouseId(int houseId) {
        Map<String, Object> map = new HashMap<String, Object>();
        BasicStorehouse basicStorehouse = basicStorehouseService.getStoreDataByHouseId(houseId);
        String  StorehouseName = "";
        if(basicStorehouse!=null){
            if(basicStorehouse.getDepotName()!=null){
                StorehouseName = basicStorehouse.getStorehouseName();
            }
        }
        map.put("StorehouseName", StorehouseName);
        return map;
    }

}