depot-business-tianjin/src/main/java/com/chinaitop/depot/business/service/impl/BusinessContractReceiveServiceImpl.java

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

import java.math.BigDecimal;
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.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.chinaitop.depot.business.controller.BusinessContractController;
import com.chinaitop.depot.business.mapper.BusinessContractReceiveMapper;
import com.chinaitop.depot.business.model.BusinessContractReceive;
import com.chinaitop.depot.business.model.BusinessContractReceiveExample;
import com.chinaitop.depot.business.model.BusinessContractReceiveExample.Criteria;
import com.chinaitop.depot.business.service.BusinessContractReceiveService;
import com.chinaitop.depot.business.service.FeignBasicService;
import com.chinaitop.depot.feignService.DepotKeeperAccountFeignService;
import com.chinaitop.depot.utils.ParameterUtil;

@Service
@SuppressWarnings("all")
public class BusinessContractReceiveServiceImpl implements BusinessContractReceiveService {

	@Resource
	private BusinessContractReceiveMapper businessContractReceiveMapper;

	@Resource
	private FeignBasicService feignBasicService;

	@Resource
	private DepotKeeperAccountFeignService feigenKeeperAccountService;

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

	@Override
	@Transactional(rollbackFor = Exception.class)
	public Map<String, String> receiveContractData(String data) throws Exception {
		Map<String, String> resultMap = new HashMap<>();
		if (StringUtils.isBlank(data)) {
			resultMap.put("status", "500");
			resultMap.put("msg", "下发数据不能为空");
			return resultMap;
		}
		JSONObject obj = JSONObject.parseObject(data);
		Map<String, Object> check_map = checkDatas(obj);
		String msg = check_map.get("msg")+"";
		if (msg.length() > 0) {
			resultMap.put("status", "500");
			resultMap.put("msg", msg);
			return resultMap;
		} else {
			BusinessContractReceive obj_map = (BusinessContractReceive) check_map.get("data");

			//先处理客户信息数据
			Integer customerId = editCustomer(obj_map.getOrgId(), obj_map.getKhmc());

			//把新增或查到的客户ID给当前合同的客户ID赋值
			obj_map.setKhid(customerId);
			obj_map.setDataType("0");

			//保存合同数据
			updateOrSave(obj_map);

			resultMap.put("status", "200");
			resultMap.put("msg", "推送成功");
		}

		return resultMap;
	}

	private Map<String, Object> checkDatas(JSONObject obj) {
		BusinessContractReceive dataobj = new BusinessContractReceive();
		List<BusinessContractReceive> list = new ArrayList<>();
		StringBuffer sbf = new StringBuffer(100);
		
		String htbh = obj.getString("htbh");
		if (StringUtils.isNotBlank(htbh)) {
			dataobj.setHtbh(htbh.trim());
		} else {
			sbf.append("合同编号不能为空,");
		}
		String htlx = obj.getString("htlx");
		if (StringUtils.isNotBlank(htlx)) {
			dataobj.setHtlx(htlx.trim());
		} else {
			sbf.append("合同类型不能为空,");
		}
		String htsl = obj.getString("htsl");
		if (StringUtils.isNotBlank(htsl)) {
			dataobj.setHtzsl(new BigDecimal(htsl));
		} else {
			sbf.append("合同数量不能为空,");
		}
		String htdj = obj.getString("dj");
		if (StringUtils.isNotBlank(htdj)) {
			dataobj.setHtdj(new BigDecimal(htdj));
		} else {
			sbf.append("合同单价不能为空,");
		}
		String htzj = obj.getString("zj");
		if (StringUtils.isNotBlank(htzj)) {
			dataobj.setHtzj(new BigDecimal(htzj));
		} else {
			sbf.append("合同总价不能为空,");
		}
		String pz = obj.getString("pz");
		if (StringUtils.isNotBlank(pz)) {
			String lypz = "";
			if (pz.equals("2130000") || pz.equals("1410000")) {
				lypz = "7144";
				logger.info("根据"+pz+"获取到的品种数据如下：");
				logger.info("原油对应的字典ID是：7144");
			} else {
				Map<String, Object> basicMap = feignBasicService.getIdByNameAndParentId(1061, null, pz);
				lypz = basicMap.get("enumId")+"";
				logger.info("根据"+pz+"获取到的品种数据如下：");
				logger.info(basicMap.toString());
			}
			if (StringUtils.isNotBlank(lypz)) {
				dataobj.setLypz(Integer.parseInt(lypz));
			} else {
				sbf.append("粮食品种的值"+pz+"有误或不合理,");
			}
		} else {
			sbf.append("粮食品种不能为空,");
		}
		String mxpz = obj.getString("mxpz");
		if (StringUtils.isNotBlank(mxpz)) {
			if (null != dataobj.getLypz()) {
				Integer enumid = null;
				if (mxpz.equals("2131000")) {
					enumid = 7145;
				} else {
					enumid = getEnumId(dataobj.getLypz(), mxpz);
				}
				logger.info("根据"+mxpz+"获取到的明细品种数据是："+enumid);
				if (null != enumid) {
					dataobj.setMxpz(enumid);
				} else {
					sbf.append("粮食明细品种的值"+mxpz+"有误或不合理,");
				}
			}
		} else {
			sbf.append("粮食明细品种不能为空,");
		}
		String lydj = obj.getString("lsdj");
		if (StringUtils.isNotBlank(lydj)) {
			lydj = lydj.replace(" ", "");
			Map<String, Object> basicMap = feignBasicService.getIdByNameAndParentId(1002, null, lydj);
			logger.info("获取到的粮食等级数据如下：");
			logger.info(basicMap.toString());
			String dj = basicMap.get("enumId")+"";
			if (StringUtils.isNotBlank(dj)) {
				dataobj.setLydj(Integer.parseInt(dj));
			} else {
				sbf.append("粮食等级的值"+lydj+"有误或不合理,");
			}
		} else {
			if ("1410000".equals(pz)) {
				dataobj.setLydj(7166);
			}
		}
		String lyxz = obj.getString("lsxz");
		if (StringUtils.isNotBlank(lyxz)) {
			Integer enumid = getEnumId(1032, lyxz);
			logger.info("根据"+lyxz+"获取到的粮食性质数据如下："+enumid);
			if (null != enumid) {
				dataobj.setLyxz(enumid);
			} else {
				sbf.append("粮食性质的值"+lyxz+"有误,");
			}
		} else {
			sbf.append("粮食等级不能为空,");
		}
		String scnf = obj.getString("scnf");
		if (StringUtils.isNotBlank(scnf)) {
			Map<String, Object> basicMap = feignBasicService.getIdByNameAndParentId(1004, scnf, null);
			logger.info("获取到的生产年份数据如下：");
			logger.info(basicMap.toString());
			String scnd = basicMap.get("enumId")+"";
			if (StringUtils.isNotBlank(scnd)) {
				dataobj.setScnf(Integer.parseInt(scnd));
				dataobj.setShnd(dataobj.getScnf());
			} else {
				sbf.append("生产年份的值"+scnf+"有误,");
			}
		} else {
			sbf.append("生产年份不能为空,");
		}
		String khmc = obj.getString("khmc");
		if (StringUtils.isNotBlank(khmc)) {
			dataobj.setKhmc(khmc.replace(" ", "").trim());
		} else {
			sbf.append("客户名称不能为空,");
		}
		String hw_sptid = obj.getString("hwbm");//市平台货位数据主键ID
		if (StringUtils.isNotBlank(hw_sptid)) {
			Map<String, Object> basicMap = feignBasicService.getWareOrTankObj(hw_sptid);
			logger.info("根据值"+hw_sptid+"获取到的货位数据如下：");
			logger.info(basicMap+"");
			if (!"0".equals(basicMap.get("houseId").toString()) && !"0".equals(basicMap.get("warehouseId").toString()) && !"0".equals(basicMap.get("orgId").toString())) {
				dataobj.setHouseId(Integer.parseInt(basicMap.get("houseId").toString()));
				if (hw_sptid.length() > 4) {//说明是粮食仓房的。如果是小于等于4，那就是油罐的数据，货位的值为空
					dataobj.setWarehouseId(Integer.parseInt(basicMap.get("warehouseId").toString()));
				}
				dataobj.setOrgId(Integer.parseInt(basicMap.get("orgId").toString()));
				dataobj.setInputTime(new Date());
				dataobj.setUpdateTime(dataobj.getInputTime());
			} else {
				sbf.append("未查询到hwbm的值对应的货位数据,");
			}
		} else {
			sbf.append("hwbm的值不能为空,");
		}
		String id = obj.getString("htbm");//市平台合同主键ID
		if (StringUtils.isNotBlank(hw_sptid)) {
			dataobj.setSptHtid(id);
		}

		Map<String, Object> resultMap = new HashMap<>();
		resultMap.put("msg", sbf.toString());
		resultMap.put("data", dataobj);

		return resultMap;
	}

	/**
	 * 根据字典父级ID和国标编码获取下面的一个字典ID
	 * @param parentId
	 * @param gbCode
	 * @return
	 */
	private Integer getEnumId(int parentId, String gbCode) {
		Integer enumId = null;
		Map<String, Object> map = feignBasicService.findConditionEnum(parentId, null, null);
		if (null != map) {
			String json_str = JSON.toJSONString(map);
			JSONObject json_obj = JSONObject.parseObject(json_str);
			JSONArray array = JSONArray.parseArray(json_obj.getString("enumList"));
			for (int i = 0; i < array.size(); i++) {
				JSONObject object = JSONObject.parseObject(array.get(i).toString());
				String code = object.getString("gbcode");
				if (code.equals(gbCode)) {
					enumId = Integer.parseInt(object.getString("id"));
					break;
				}
			}
		}
		return enumId;
	}

	@Override
	public List<BusinessContractReceive> queryByExample(String htbh, Integer orgId, Integer houseId, Integer warehouseId, String htlx)
			throws Exception {
		List<BusinessContractReceive> list = null;
		BusinessContractReceiveExample example = new BusinessContractReceiveExample();
		Criteria criteria = example.createCriteria();
		if (StringUtils.isNotBlank(htbh)) {
			criteria.andHtbhLike("%"+htbh+"%");
		}
		if (null != orgId) {
			criteria.andOrgIdEqualTo(orgId);
		}
		if (null != houseId) {
			criteria.andHouseIdEqualTo(houseId);
		}
		if (null != warehouseId) {
			criteria.andWarehouseIdEqualTo(warehouseId);
		}
		if (StringUtils.isNotBlank(htlx)) {
			criteria.andHtlxEqualTo(htlx);
		}
		example.setOrderByClause("input_time desc");
		list = businessContractReceiveMapper.selectByExample(example);
		return list;
	}

	@Override
	public BusinessContractReceive findbyParmaryKey(Integer id) throws Exception {
		BusinessContractReceive businessContractReceive = businessContractReceiveMapper.selectByPrimaryKey(id);
		return businessContractReceive;
	}

	private Integer editCustomer(Integer orgId, String customerName) throws Exception {
		//查询这个客户在这个库是否存在
		Integer customerId = feigenKeeperAccountService.queryCustomerObj(orgId, 3153, customerName);

		//如果不存在就新增一条不完整的客户
		if (null == customerId) {//说明这个客户没再库级维护
			//形成客户编码
			StringBuffer sbf = new StringBuffer();
			//把单位ID格式化成3位，不足三位的补0
			String sxm = String.format("%03d", orgId);
			sbf.append("KH-").append(sxm).append("-").append(ParameterUtil.getDateYMDHMS(new Date()));

			JSONObject json = new JSONObject();
			json.put("name", customerName);
			json.put("classify", 3153);
			json.put("sfwz", "1");//客户数据是否完整(0:完整,1:不完整)
            json.put("customerNumber", sbf.toString());

			Map<String, Object> modelMap = feigenKeeperAccountService.save(json.toString(), orgId);
			if ("error".equals(modelMap.get("status"))) {
				throw new Exception("不完整客户保存异常");
			} else {
				customerId = Integer.parseInt(modelMap.get("id").toString());
			}
		}
		return customerId;
	}

	@Override
	public void updateOrSave(BusinessContractReceive businessContractReceive) throws Exception {
		//构建条件
		BusinessContractReceiveExample example = new BusinessContractReceiveExample();
		BusinessContractReceiveExample.Criteria criteria = example.createCriteria();
		criteria.andSptHtidEqualTo(businessContractReceive.getSptHtid());

		//查询符合条件的数据
		List<BusinessContractReceive> list = businessContractReceiveMapper.selectByExample(example);

		//没有符合的就新增，有的话就修改
		if (null == list || list.size() == 0) {
			businessContractReceive.setYjssl(new BigDecimal(0));
			businessContractReceiveMapper.insert(businessContractReceive);
		} else {
			businessContractReceive.setId(list.get(0).getId());
			businessContractReceive.setUpdateTime(new Date());
			businessContractReceiveMapper.updateByExample(businessContractReceive, example);
		}
	}

	@Override
	public Map<String, String> updateYjssl(Integer htid, String bcjssl) throws Exception {
		Map<String, String> map = new HashMap<String, String>();
		BusinessContractReceive businessContractReceive = businessContractReceiveMapper.selectByPrimaryKey(htid);
		if (null == businessContractReceive) {
			map.put("status", "500");
			map.put("msg", "未检测到原合同信息,请联系管理员");
			return map;
		} else {
			BigDecimal new_bcjssl = new BigDecimal(bcjssl);//本次结算数量
			BigDecimal yjssl = businessContractReceive.getYjssl();
			yjssl = yjssl.add(new_bcjssl);
			businessContractReceive.setYjssl(yjssl);
			businessContractReceiveMapper.updateByPrimaryKey(businessContractReceive);
			map.put("status", "200");
			map.put("msg", "操作成功");
		}
		return map;
	}
}