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

package com.chinaitop.depot.basic.controller;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

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

import com.chinaitop.depot.Object.HwObj;
import com.fasterxml.jackson.core.type.TypeReference;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.chinaitop.depot.basic.model.BasicStorehouse;
import com.chinaitop.depot.basic.model.BasicTank;
import com.chinaitop.depot.basic.model.BasicWarehouse;
import com.chinaitop.depot.basic.model.BasicWarehouseExample;
import com.chinaitop.depot.basic.model.BasicWarehouseExample.Criteria;
import com.chinaitop.depot.basic.model.BasicWarehouseVO;
import com.chinaitop.depot.basic.service.BasicStorehouseService;
import com.chinaitop.depot.basic.service.BasicTankService;
import com.chinaitop.depot.basic.service.BasicWarehouseService;
import com.chinaitop.depot.basic.service.impl.BasicStorehouseServiceImpl;
import com.chinaitop.depot.basic.service.impl.BasicWarehouseServiceImpl;
import com.chinaitop.depot.utils.BusinessUtils;
import com.chinaitop.utils.ParameterUtil;
import com.chinaitop.utils.WarehouseDataSynchronization;
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
 *
 */
@RestController
@RequestMapping(value="/Warehouse")
@Api(value= "BasicWarehouseController", description = "货位管理控制类")
@SuppressWarnings("all")
public class BasicWarehouseController {

	final static Logger logger = LoggerFactory.getLogger(BasicWarehouse.class);

	@Resource
	private BasicWarehouseService basicWarehouseService;
	
	@Resource
	private BasicStorehouseService basicStorehouseService;

	@Resource
	private BasicTankService basicTankService;

	@RequestMapping(value="/getList", method = RequestMethod.GET)
	@ApiOperation(value="查询 货位 信息列表", notes = "查询 货位 信息列表，支持分页")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "pageNum", value = "页码", paramType = "query"),
		@ApiImplicitParam(name = "pageSize", value = "每页条数", paramType = "query"),
		@ApiImplicitParam(name = "storehouseId", value = "仓房ID", paramType = "query"),
		@ApiImplicitParam(name = "warehouseId", value = "货位ID", paramType = "query"),
		@ApiImplicitParam(name = "warehouseName", value = "货位名称", paramType = "query"),
		@ApiImplicitParam(name = "graindepotId", value = "单位ID", paramType = "query"),
		@ApiImplicitParam(name = "libraryType", value = "粮库类型", paramType = "query"),
		@ApiImplicitParam(name = "delFlag", value = "是否删除", paramType = "query")
	})
	public PageInfo<BasicWarehouse> getList(Integer pageNum, Integer pageSize, Integer storehouseId, Integer warehouseId, 
			String warehouseName, Integer graindepotId, String libraryType, Integer delFlag) {
		BasicWarehouseExample wareExample = new BasicWarehouseExample();
		Criteria criteria = wareExample.createCriteria();
		List<BasicWarehouse> list = null;
		try {
			
			// 拼接查询条件
			if (!"".equals(warehouseName) && warehouseName != null) {
				criteria.andWarehouseNameLike("%"+warehouseName+"%");
			}
			if (null != storehouseId && !"".equals(storehouseId)) {
				criteria.andStorehouseIdEqualTo(storehouseId); //只查询顶级菜单
			}
			if (null != warehouseId && !"".equals(warehouseId) ){
				criteria.andWarehouseIdEqualTo(warehouseId);
			}
			if (null != libraryType) {
				//如果是3则说明是空仓过滤
				if(ParameterUtil.isequal("3",libraryType)){
					//1说明是空仓
					criteria.andCrkStatusEqualTo("1");
				}else {
					criteria.andLibraryTypeEqualTo(libraryType);
				}
			}

			/* 查询当前库下的数据 */
			criteria.andOrgIdEqualTo(graindepotId);

			if (null != pageNum && null != pageSize) {
				PageHelper.startPage(pageNum, pageSize);
			}
			
			// 值为1是没删除的数据(在用),0是已删除的数据(弃用)
			if (null != delFlag) {
				criteria.andDelFlagEqualTo(delFlag); 
			}
			wareExample.setOrderByClause("storehouse_id asc");
			list = basicWarehouseService.findCondition(wareExample);
		} catch (Exception e) {
			//e.printStackTrace();
			logger.error(e.getMessage(), e);
		}
		PageInfo<BasicWarehouse> pageInfo = new PageInfo<BasicWarehouse>(list);
		return pageInfo;
	}
	
	/**
	 * 按货位ID查询一条数据
	 * 
	 * @param id 数据ID
	 * @return
	 */
	@RequestMapping(value="/findByWarehouse", method = RequestMethod.GET)
	@ApiOperation(value="按货位ID查询一条数据", notes = "按货位ID查询一条数据")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "id", value = "数据ID", paramType = "query")
	})
	public BasicWarehouse findByWarehouse(Integer id) {
		BasicWarehouse basicWarehouse = new BasicWarehouse();
		if (id != null) {
			basicWarehouse = basicWarehouseService.findByParmaryKey(id);
		}
		return basicWarehouse;
	}

	/**
	 * 更新货位信息
	 * 
	 * @param warehouseJson JSON数据对象
	 * @return
	 */
	@RequestMapping(value="/edit", method = RequestMethod.POST)
	@ApiOperation(value="更新货位信息", notes = "更新货位信息")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "warehouseJson", value = "JSON货位数据对象", paramType = "form"),
		@ApiImplicitParam(name = "userInfo", value = "JSON登录数据对象", paramType = "form"),
		@ApiImplicitParam(name = "orgInfoJson", value = "JSON登录粮库的数据对象", paramType = "form")
	})
	public Map<String, Object> edit(String warehouseJson, String userInfo, String orgInfoJson) {
		Map<String, Object> map = new HashMap<String, Object>();
        try {
			basicWarehouseService.edit(warehouseJson, userInfo, orgInfoJson);
			map.put("status", "success");
		} catch (Exception e) {
			//e.printStackTrace();
			logger.error(e.getMessage(), e);
			map.put("status", "error");
            map.put("msg", "保存失败！");
		}
		
		return map;
	}

	/**
	 * 删除货位信息
	 * 
	 * @param id 数据对象
	 * @return
	 */
	@RequestMapping(value="/remove", method = RequestMethod.POST)
	@ApiOperation(value="删除货位信息", notes = "删除货位信息")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "id", value = "数据ID", paramType = "form")
	})
	public Map<String, Object> remove(Integer id, Integer storehouseId) {
		Map<String, Object> map = new HashMap<String, Object>();
        try {
        	//先查询这条仓房数据,进行判断
        	BasicWarehouse basicWarehouse = basicWarehouseService.findByParmaryKey(id);
        	//先查询这条货位数据，通过判断如果为弃用状态则根据仓房状态进行修改,若仓房状态为应用状态,则不对货位状态进行修改
        	BasicStorehouse basicStorehouse = basicStorehouseService.findByPrimary(storehouseId);
        	Integer delFlag = basicWarehouse.getDelFlag();
        	if (delFlag == 1 || "1".equals(delFlag)) {
				delFlag = 0;
			} else if (delFlag == 0 || "0".equals(delFlag)) {
				delFlag = 1;
				//判断为弃用改应用状态,则进行应用
				basicStorehouse.setDelFlag(delFlag);
				basicStorehouseService.updateBasicStorehouse(basicStorehouse);
			}

        	basicWarehouse.setDelFlag(delFlag);
			if (id != null) {
				basicWarehouseService.update(basicWarehouse);;
			}
			map.put("status", "success");
		} catch (Exception e) {
			e.printStackTrace();
			map.put("status", "error");
            map.put("msg", "操作失败！");
		}
		
		return map;
	}
	
	/**
	 * 根据单位和仓房查询货位信息（货位对外接口）
	 * 
	 * @param unitId 单位ID
	 * @param storehouseId 仓房ID
	 * @return
	 */
	@RequestMapping(value="/getWarehouse", method = RequestMethod.GET)
	@ApiOperation(value="根据单位和仓房查询货位信息（货位对外接口）", notes = "根据单位和仓房查询货位信息（货位对外接口）")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "unitId", value = "单位ID", paramType = "query"),
		@ApiImplicitParam(name = "storehouseId", value = "仓房ID", paramType = "query"),
		@ApiImplicitParam(name = "libraryType", value = "库类型(0主粮库,1代储库)", paramType = "query")
	})
	public Map<String, Object> getWarehouse(Integer unitId, Integer storehouseId, String libraryType) {
		Map<String, Object> map = null;
		
		map = basicWarehouseService.getWarehouse(unitId, storehouseId, libraryType);
		
		return map;
	}

	@RequestMapping(value="/findWareCode", method=RequestMethod.GET)
	@ApiOperation(value="防止货位编码重复添加", notes = "storehouseCode参数")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "storehouseId", value = "仓房ID", paramType = "query"),
			@ApiImplicitParam(name = "warehouseCode", value = "货位编码", paramType = "query"),
			@ApiImplicitParam(name = "wareId", value = "货位ID", paramType = "query"),
			@ApiImplicitParam(name = "libraryType", value = "判断是代储点还是主库", paramType = "query")
			})
	public String findWareCode(HttpServletRequest request, Integer storehouseId, String warehouseCode, Integer wareId, String libraryType) {
		String codeFlag = "";
		List<BasicWarehouse> list = null;
		Integer orgId = (Integer) request.getSession().getAttribute("orgId");
		BasicWarehouseExample warehouseExample = new BasicWarehouseExample();
		Criteria cria = warehouseExample.createCriteria();
		cria.andStorehouseIdEqualTo(storehouseId);
		cria.andWarehouseCodeEqualTo(warehouseCode);
		cria.andOrgIdEqualTo(orgId);
		cria.andWarehouseIdNotEqualTo(wareId);
		//cria.andLibraryTypeEqualTo(libraryType);
		try {
			list = basicWarehouseService.findCondition(warehouseExample);
			if (null != list && list.size() > 0) {
				codeFlag = "0";
			} else {
				codeFlag = "1";
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return codeFlag;
	}

	//库点信息同步
	@SuppressWarnings("all")
	@RequestMapping("/warehouseSynchronization")
	@ApiOperation(value="货位信息同步", notes = "货位信息同步")
	public void orgInfoSynchronization() {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
		List list = WarehouseDataSynchronization.queryWarehouse();
		BasicWarehouseExample wareExample = new BasicWarehouseExample();
		List<BasicWarehouse> wareList = basicWarehouseService.findCondition(wareExample);
		for(BasicWarehouse warehouse : wareList) {
			int num = 0;
			for(int i=0;i<list.size();i++) {
				Map<String,Object> map = (Map<String,Object>)list.get(i);
				String hwbh = ObjectUtils.toString(map.get("hwbh"),"");//库点编码
				String refreshTime = ObjectUtils.toString(map.get("refreshTime"),"");
				if(hwbh.equals(ObjectUtils.toString(warehouse.getWarehouseCode(),""))) {
					if(!refreshTime.equals(format.format(warehouse.getUpdatedate()))) {
						WarehouseDataSynchronization.warehouseSynchronizationUpdate(map, warehouse);
					}
					break;
				}else if(num == (list.size()-1)){
					WarehouseDataSynchronization.warehouseSynchronizationInsert(warehouse);
				}else {
					num = num+1;
				}
			}
		}
	}
	
	
	/**
	 * 根据货位编码编码获取有关信息用于和市平台对接
	 */
	@RequestMapping(value="/getWareDataByHwbm",produces = MediaType.APPLICATION_JSON_VALUE, method = RequestMethod.GET)
	@ApiOperation(value="根据货位编码获取有关信息用于和市平台对接", notes = "根据货位编码获取有关信息用于和市平台对接")
	public Map<String, Object> getWareDataByHwbm(String hwbm) {
		Map<String, Object> map = new HashMap<String, Object>();
		Integer houseId = 0;
		String storehouseName = "";
		Integer wareHouseId = 0;
		String warehouseName = "";
		Integer orgId = 0;
		String transUnitName = "";
		String strs = hwbm.substring(0, 3);
        if ("120".equals(strs)) {
        	BasicWarehouseVO basicWarehouse = basicWarehouseService.getWareDataByHwbm(hwbm);
        	if (basicWarehouse != null) {
        		if(basicWarehouse.getStorehouseId()!=null){
        			houseId = basicWarehouse.getStorehouseId();
        		}
        		if(basicWarehouse.getWarehouseId()!=null){
        			wareHouseId = basicWarehouse.getWarehouseId();
        		}
        		if(basicWarehouse.getWarehouseName()!=null){
        			warehouseName = basicWarehouse.getWarehouseName();
        		}
        		if(basicWarehouse.getOrgId()!=null){
        			orgId =  basicWarehouse.getOrgId();
        		}
        		if(basicWarehouse.getDepotName()!=null){
        			transUnitName = basicWarehouse.getDepotName();
        		}
        		if(basicWarehouse.getStorehouseName()!=null){
        			storehouseName = basicWarehouse.getStorehouseName();
        		}
        	}
        } else {
        	BasicTank tank = basicTankService.findByPrimary(hwbm);
        	if (null != tank) {
        		if (StringUtils.isNotBlank(tank.getId())) {
        			houseId = Integer.parseInt(tank.getId());
        			wareHouseId = Integer.parseInt(tank.getId());
        		}
        		if (tank.getStoragetankName() != null) {
        			warehouseName = tank.getStoragetankName();
        			storehouseName = tank.getStoragetankName();
        		}
        		if(tank.getOrgId()!=null){
        			orgId =  tank.getOrgId();
        		}
        	}
        }
		map.put("houseId", houseId);
		map.put("wareHouseId", wareHouseId);
		map.put("warehouseName", warehouseName);
		map.put("orgId", orgId);
		map.put("transUnitName", transUnitName);
		map.put("storehouseName", storehouseName);
		return map;
	}

	@RequestMapping(value="/getPageInfoWareAndTank", method=RequestMethod.GET)
	@ApiOperation(value="查询空的货位和油罐列表", notes = "支持分页")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "pageNum", value = "页码", paramType = "query"),
		@ApiImplicitParam(name = "pageSize", value = "每页条数", paramType = "query"),
		@ApiImplicitParam(name = "orgId", value = "组织机构ID", paramType = "query"),
		@ApiImplicitParam(name = "houseId", value = "仓房ID", paramType = "query"),
		@ApiImplicitParam(name = "warehouseId", value = "货位ID", paramType = "query")
	})
	public PageInfo<Map<String, Object>> getPageInfoWareAndTank(Integer pageNum, Integer pageSize, Integer orgId, 
			Integer houseId, Integer warehouseId) {
		List<Map<String, Object>> list = null;
		try {
			if (null != pageNum && null != pageSize) {
				PageHelper.startPage(pageNum, pageSize);
			}
			list = basicWarehouseService.selectWareAndTank(orgId, houseId, warehouseId);
		} catch (Exception e) {
			//e.printStackTrace();
			logger.error(e.getMessage(), e);
		}
		PageInfo<Map<String, Object>> pageInfo = new PageInfo<Map<String, Object>>(list);
		return pageInfo;
	}

	@RequestMapping(value="/updateWarehouseCrkStatus", method=RequestMethod.POST)
	@ApiOperation(value="修改货位的出入库状态值", notes = "修改货位的出入库状态值")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "wareJson", value = "数据串", paramType = "form")
	})
	public void updateWarehouseCrkStatus(String wareJson) {

		String date = ParameterUtil.getSysDateTime();
		logger.info("时间："+date+"，出入库状态回写接口，封仓和成品粮出入库调用，接收参数是："+wareJson);

		/**
		 * 逻辑说明：本接口只有库级平台粮情专卡提交和成品粮出入库的分仓保管账菜单录入数据提交时调用
		 * 1、粮情专卡提交调用时：只有一个状态，那就是3(封仓状态)，处理时直接修改成3
		 * 2、成品粮分仓保管账菜单入库数据提交时调用：直接修改为入库状态2，或者出库状态4
		 */
		try {
			if (StringUtils.isNotEmpty(wareJson)) {
				/* 将获取到的json串转换成HwObj集合 */
				wareJson = wareJson.replace("crk_status", "status");
				ObjectMapper objectMapper = new ObjectMapper();
				List<HwObj> hwObjs = objectMapper.readValue(wareJson, new TypeReference<List<HwObj>>() {
				});
				basicWarehouseService.editRuleMethod(hwObjs);
				logger.info("时间：" + date + "，出入库状态回写接口，封仓调用，调用成功！");
			}
		} catch (Exception e) {
			logger.info("时间："+date+"，出入库状态回写接口，封仓调用，调用失败！");
			e.printStackTrace();
		}
	}
	
	
	@RequestMapping(value="/getHouseIdBySptDataID", method=RequestMethod.GET)
	@ApiOperation(value="查询仓房id根据货位编码", notes = "查询仓房id根据货位编码")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "sptDataId", value = "和市平台对接的货位编码", paramType = "query")
	})
	public String getHouseIdBySptDataID(String sptDataId) {
		String a = "0";	
		BasicWarehouseExample wareExample = new BasicWarehouseExample();
		Criteria criteria = wareExample.createCriteria();
		criteria.andSptDataidEqualTo(sptDataId);
		List<BasicWarehouse> list = basicWarehouseService.findCondition(wareExample);
		if(list.size()>0){
			a = list.get(0).getStorehouseId().toString();
		}
		return a;
	}

	@RequestMapping(value="/getWareOrTankObj", method=RequestMethod.GET)
	@ApiOperation(value="按市平台货位数据ID查询一条货位数据", notes = "")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "sptDataId", value = "和市平台对接的货位数据ID", paramType = "query")
	})
	public Map<String, Object> getWareOrTankObj(String sptDataId) {
		Map<String, Object> map = new HashMap<String, Object>();
		try {
			map = basicWarehouseService.getWareOrTank(sptDataId);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return map;
	}

	@RequestMapping(value="/getCrkStatusList", method=RequestMethod.GET)
	@ApiOperation(value="按条件查询某种货位状态的数据", notes = "")
	@ApiImplicitParams({
		@ApiImplicitParam(name = "lylx", value = "粮油类型(0:原粮,1:成品粮)", required=true, paramType = "query"),
		@ApiImplicitParam(name = "crkStatus", value = "货位状态值1空仓,2入库中,3封仓,4出库中", required=true, paramType = "query"),
		@ApiImplicitParam(name = "orgId", value = "库ID", required=true, paramType = "query")
	})
	public List<BasicWarehouse> getCrkStatusList(String lylx, String crkStatus, Integer orgId) {
		List<BasicWarehouse> list = null;
		try {
			list = basicWarehouseService.getCrkStatusList(lylx, crkStatus, orgId);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return list;
	}
}