depot-basic-tianjin/src/main/java/com/chinaitop/depot/basic/service/impl/BasicWarehouseServiceImpl.java

package com.chinaitop.depot.basic.service.impl;

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

import javax.annotation.Resource;

import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSONObject;
import com.chinaitop.depot.Object.HwObj;
import com.chinaitop.depot.Object.YwConstant;
import com.chinaitop.depot.basic.mapper.BasicStorehouseMapper;
import com.chinaitop.depot.basic.mapper.BasicTankHwMapper;
import com.chinaitop.depot.basic.mapper.BasicTankMapper;
import com.chinaitop.depot.basic.mapper.BasicWarehouseMapper;
import com.chinaitop.depot.basic.model.BasicStorehouse;
import com.chinaitop.depot.basic.model.BasicTank;
import com.chinaitop.depot.basic.model.BasicTankExample;
import com.chinaitop.depot.basic.model.BasicTankHw;
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.BasicWarehouseService;
import com.chinaitop.depot.utils.BusinessUtils;
import com.chinaitop.utils.ParameterUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

@Service
public class BasicWarehouseServiceImpl implements BasicWarehouseService {

	@Resource
	private BasicWarehouseMapper warehouseMapper;

	@Resource
	private BasicTankMapper bankMapper;

	@Resource
	private BasicTankHwMapper tankHwMapper;

	@Resource
	private BasicStorehouseMapper storehouseMapper;
	
	@Override
	public void add(BasicWarehouse basicWarehouse) {
		warehouseMapper.insertSelective(basicWarehouse);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void edit(String warehouseJson, String userInfo, String orgInfoJson) throws Exception {

		JSONObject user = null;
		Integer orgId = null;
		String userName = "";

		//解析用户信息
		if (null != userInfo && !"".equals(userInfo)) {
			user = JSONObject.parseObject(userInfo);
			orgId = Integer.parseInt(user.get("orgId") == null?"":user.get("orgId").toString());
			userName = user.get("username") == null?"":user.get("username").toString();
		}

		//获取当前时间
		Date date = new Date();

		// JSON字符串转对象
		ObjectMapper mapper = new ObjectMapper();

		BasicWarehouse new_warehouse = (BasicWarehouse)mapper.readValue(warehouseJson, BasicWarehouse.class);
		String hwdm = "";
		if (new_warehouse.getWarehouseId() != null) {
			new_warehouse.setUpdatename(userName);
			new_warehouse.setUpdatedate(date);
			BasicStorehouse storehouse = storehouseMapper.selectByPrimaryKey(new_warehouse.getStorehouseId());
			new_warehouse.setHwdm(BusinessUtils.setBZhwbm(storehouse.getAjbm(), new_warehouse.getWarehouseCode()));
			//new_warehouse.setUpdatetime(date);
			warehouseMapper.updateByPrimaryKey(new_warehouse);

			//如果是出库或空仓，需要把当前货位的业务数据进行归档等操作
			if ("1".equals(new_warehouse.getCrkStatus()) || "4".equals(new_warehouse.getCrkStatus())) {
				Map<String, Object> lqkmap = new HashMap<String, Object>();
				lqkmap.put("wareId", new_warehouse.getWarehouseId());
				lqkmap.put("orgId", new_warehouse.getOrgId());
				//注意：从仓房管理和货位管理、油罐管理这三个菜单保存的数据，只要是空仓或出库，原粮和成品粮的粮情卡都要归档
				warehouseMapper.updateYlLqkGd(lqkmap);//归档原粮粮情卡
				warehouseMapper.updateCplLqkGd(lqkmap);//归档成品粮粮情卡
				warehouseMapper.updateQualitycheck(lqkmap);//归档自检数据
			}
		} else {
			new_warehouse.setWarehouseStatus(2963); //添加时默认货位状态为空仓
			new_warehouse.setOrgId(orgId);
			if(!ParameterUtil.isequal(new_warehouse.getLibraryType(),"1")){
				new_warehouse.setDepotId(orgId);
			}
			if (!"".equals(new_warehouse.getWarehouseCode())) {
				BasicStorehouse storehouse = storehouseMapper.selectByPrimaryKey(new_warehouse.getStorehouseId());
				hwdm = BusinessUtils.setBZhwbm(storehouse.getAjbm(), new_warehouse.getWarehouseCode());
				new_warehouse.setHwdm(hwdm.trim());
			}
			new_warehouse.setCreatename(userName);
			new_warehouse.setCreatedate(date);
			//new_warehouse.setUpdatetime(date);
			new_warehouse.setDelFlag(1);
			add(new_warehouse);
		}
	}

	@Override
	public void update(BasicWarehouse basicWarehouse) {
		warehouseMapper.updateByPrimaryKeySelective(basicWarehouse);
	}

	@Override
	public void delete(Integer id) {
		warehouseMapper.deleteByPrimaryKey(id);
	}

	@Override
	public BasicWarehouse findByParmaryKey(Integer id) {
		return warehouseMapper.selectByPrimaryKey(id);
	}

	@Override
	public List<BasicWarehouse> findCondition(BasicWarehouseExample example) {
		return warehouseMapper.selectByExample(example);
	}

	@Override
	public Map<String, Object> getWarehouse(Integer unitId, Integer storehouseId, String libraryType) {

		/* 返回大对象 */
		Map<String, Object> map = new HashMap<String, Object>();

		/* 设置货位的按ID转化对象 */
		List<BasicWarehouse> warelist = getWareList(unitId, null, null, null);  //获取当前库所有货位
		Map<Integer, Object> wareMap = new HashMap<Integer, Object>();
		if (null != warelist && warelist.size() != 0) {
			for (BasicWarehouse ware : warelist) {
				wareMap.put(ware.getWarehouseId(), ware);
			}
		} else {
			warelist = new ArrayList<BasicWarehouse>();
		}
		map.put("wares", wareMap); // 数据列表页面转换对象

		/* 获取有效的货位下拉列表 */
		List<BasicWarehouse> list = getWareList(unitId, storehouseId, libraryType, 1); //获取库点下的某个仓房中的的货位
		map.put("wareList", list); //货位下拉列表集合

		return map;
	}

	/**
	 * 按条件查询货位数据
	 * 
	 * @param orgId 单位ID
	 * @param houseId 仓房ID
	 * @param libraryType 是否代储
	 * @param delFlag 是否在用
	 * @return
	 */
	@SuppressWarnings("all")
	private List<BasicWarehouse> getWareList(Integer orgId, Integer houseId, String libraryType, Integer delFlag) {
		List<BasicWarehouse> list = null;
		BasicWarehouseExample example = new BasicWarehouseExample();
		Criteria criteria = example.createCriteria();
		try {
			if (null != orgId) {
				criteria.andOrgIdEqualTo(orgId);
			}
			if (null != houseId) {
				criteria.andStorehouseIdEqualTo(houseId);
			}
			if (libraryType != null && !"".equals(libraryType)) {
				criteria.andLibraryTypeEqualTo(libraryType);
			}
			if (null != delFlag) {
				criteria.andDelFlagEqualTo(delFlag);
			}
			example.setOrderByClause("warehouse_id ASC");
			list = warehouseMapper.selectByExample(example);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			return list;
		}
	}

	@Override
	public void deletEexample(Integer storehouseId) {
		//条件
		BasicWarehouseExample example = new BasicWarehouseExample();
		Criteria criteria = example.createCriteria();
		criteria.andStorehouseIdEqualTo(storehouseId);
		criteria.andDelFlagEqualTo(1);

		//要修改的值
		BasicWarehouse warehouse = new BasicWarehouse();
		warehouse.setDelFlag(0);
		warehouseMapper.updateByExampleSelective(warehouse, example);
	}

	
	@Override
	public BasicWarehouseVO getWareDataByHwbm(String hwbm) {
		// TODO Auto-generated method stub
		return warehouseMapper.getWareDataByHwbm(hwbm);
	}

	@Override
	public void updateWareStatus(Map<String, Object> param) {
		String status = param.get("status").toString();
		BasicWarehouse ware = new BasicWarehouse();
		ware.setWarehouseId(Integer.parseInt(param.get("wareId").toString()));
		ware.setCrkStatus(status);
		ware.setUpdatetime(new Date());
		if ("1".equals(status)) {//如果是空仓，将粮油类型设置为空
			ware.setLylx("");
		} else {
			ware.setLylx(param.get("lylx").toString());
		}
		warehouseMapper.updateByPrimaryKeySelective(ware);
	}

	@Override
	@Transactional(rollbackFor = Exception.class)
	public void saveOrUpdate(BasicStorehouse storehouse, String warehouseJson) throws Exception {
		ObjectMapper mappers = new ObjectMapper();
		List<BasicWarehouse> list = mappers.readValue(warehouseJson, new TypeReference<List<BasicWarehouse>>(){});

		String hwdm = "";
		for (BasicWarehouse warehouse : list) {
			if (!"".equals(warehouse.getWarehouseCode())) {
				hwdm = BusinessUtils.setBZhwbm(storehouse.getAjbm(), warehouse.getWarehouseCode());
				warehouse.setHwdm(hwdm);
			}
			if (null == warehouse.getWarehouseId()) {//没有货位ID那就是新增
				warehouse.setStorehouseId(storehouse.getStorehouseId());
				warehouse.setCreatename(storehouse.getCreatename());
				warehouse.setCreatedate(storehouse.getCreatedate());
				warehouse.setOrgId(storehouse.getOrgId());
				warehouseMapper.insertSelective(warehouse);
			} else {
				warehouse.setUpdatename(storehouse.getUpdatename());
				warehouse.setUpdatedate(storehouse.getUpdatedate());
				warehouseMapper.updateByPrimaryKeySelective(warehouse);

				//如果是出库或空仓，需要把当前货位的业务数据进行归档等操作
				if ("1".equals(warehouse.getCrkStatus()) || "4".equals(warehouse.getCrkStatus())) {
					Map<String, Object> lqkmap = new HashMap<String, Object>();
					lqkmap.put("wareId", warehouse.getWarehouseId());
					lqkmap.put("orgId", warehouse.getOrgId());
					warehouseMapper.updateYlLqkGd(lqkmap);//归档原粮粮情卡
					warehouseMapper.updateCplLqkGd(lqkmap);//归档成品粮粮情卡
					warehouseMapper.updateQualitycheck(lqkmap);//归档自检数据
				}
			}
		}
	}

	@Override
	public void editRuleMethod(List<HwObj> hwObjs) throws Exception {
		hwObjs.forEach(obj-> {
			if (YwConstant.YW_LX_YG.equals(obj.getYwlx())) {//油罐
				BasicTank banks = bankMapper.selectByPrimaryKey(obj.getWareId());
				//检查保存的粮油类型是否对应(成品粮或者原粮)
				if (obj.getLylx().equals(banks.getLylx()) || StringUtils.isBlank(banks.getLylx())) {
					BasicTank bank = new BasicTank();
					bank.setId(obj.getWareId());
					bank.setCrkStatus(obj.getStatus());
					if (YwConstant.KC_STATUS.equals(obj.getStatus())) {//如果是空仓则把粮油类型置为空
						bank.setLylx("");
					} else {
						bank.setLylx(obj.getLylx());
					}
					bankMapper.updateByPrimaryKeySelective(bank);
					BasicTankHw tankHw = new BasicTankHw();
					tankHw.setId(Integer.parseInt(obj.getWareId()));
					tankHw.setCrkStatus(obj.getStatus());
					tankHw.setZhgxsj(new Date());
					tankHwMapper.updateByPrimaryKeySelective(tankHw);
					//如果不是封仓，需要把当前货位的业务数据进行归档等操作
					if (!"3".equals(obj.getStatus())) {//出库或者空仓
						Map<String, Object> lqkmap = new HashMap<String, Object>();
						lqkmap.put("storehouseId", obj.getWareId());
						lqkmap.put("orgId", obj.getOrgId());
						warehouseMapper.updateQualitycheck(lqkmap);//归档自检数据
					}
				}
			} else if (YwConstant.YW_LX_LC.equals(obj.getYwlx())) {//粮仓
				BasicWarehouse ware = warehouseMapper.selectByPrimaryKey(Integer.parseInt(obj.getWareId()));
				if (obj.getLylx().equals(ware.getLylx()) || StringUtils.isBlank(ware.getLylx())) {
					ware.setCrkStatus(obj.getStatus());
					ware.setUpdatetime(new Date());
					if (YwConstant.KC_STATUS.equals(obj.getStatus())) {//如果是空仓，将粮油类型设置为空
						ware.setLylx("");
					} else {
						ware.setLylx(obj.getLylx());
					}
					warehouseMapper.updateByPrimaryKeySelective(ware);
					//如果不是封仓，需要把当前货位的业务数据进行归档等操作
					if (!"3".equals(obj.getStatus())) {
						Map<String, Object> lqkmap = new HashMap<String, Object>();
						lqkmap.put("wareId", obj.getWareId());
						lqkmap.put("orgId", obj.getOrgId());
						warehouseMapper.updateQualitycheck(lqkmap);//归档自检数据
					}
				}
			}
		});
	}

	@Override
	public List<Map<String, Object>> selectWareAndTank(Integer orgId, Integer houseId, Integer warehouseId) throws Exception {
		// 拼接查询条件
		Map<String, Object> map = new HashMap<>();
		map.put("orgId", orgId);
		if (null != houseId) {
			map.put("houseId", houseId);
		}
		if (null != warehouseId) {
			map.put("warehouseId", warehouseId);
		}
		List<Map<String, Object>> list = warehouseMapper.selectWareAndTank(map);
		return list;
	}

	@Override
	public Map<String, Object> getWareOrTank(String sptDataId) throws Exception {
		Map<String, Object> map = new HashMap<String, Object>();
		Integer houseId = 0;
		Integer wareHouseId = 0;
		Integer orgId = 0;
		
		if (sptDataId.length() > 4) {//这是粮仓的货位
			BasicWarehouseExample wareExample = new BasicWarehouseExample();
			Criteria criteria = wareExample.createCriteria();
			criteria.andSptDataidEqualTo(sptDataId);
			List<BasicWarehouse> list = warehouseMapper.selectByExample(wareExample);
			if(list.size()>0){
				houseId = list.get(0).getStorehouseId();
				wareHouseId = list.get(0).getWarehouseId();
				orgId = list.get(0).getOrgId();
			}
		} else {//油罐的
			BasicTankExample example = new BasicTankExample();
			BasicTankExample.Criteria criteria = example.createCriteria();
			criteria.andSptDataidEqualTo(sptDataId);
			List<BasicTank> list = bankMapper.selectByExample(example);
			if(null != list && list.size() > 0){
				BasicTank basicTank = list.get(0);
				houseId = Integer.parseInt(basicTank.getId());
				wareHouseId = houseId;
				orgId = basicTank.getOrgId();
			}
		}
		map.put("houseId", houseId);
		map.put("warehouseId", wareHouseId);
		map.put("orgId", orgId);
		return map;
	}

	@Override
	public List<BasicWarehouse> getCrkStatusList(String lylx, String crkStatus, Integer orgId) {
		BasicWarehouse ware = new BasicWarehouse();
		ware.setLylx(lylx);
		ware.setCrkStatus(crkStatus);
		ware.setOrgId(orgId);
		List<BasicWarehouse> list = warehouseMapper.getCrkStatusList(ware);
		return list;
	}

}