Lianxun_Java.git

			@@ -2,6 +2,9 @@

			import com.alibaba.fastjson.JSONArray;
			import com.alibaba.fastjson.JSONObject;
			import com.java110.common.constant.ActionTypeConstant;
			import com.java110.common.constant.AttrCdConstant;
			import com.java110.common.constant.CommonConstant;
			import com.java110.common.log.LoggerEngine;
			import com.java110.common.util.ProtocolUtil;
			import com.java110.config.properties.EventProperties;
			@@ -14,6 +17,7 @@
			import com.java110.entity.order.OrderListAttr;
			import com.java110.feign.base.IPrimaryKeyService;
			import com.java110.order.dao.IOrderServiceDao;
			import com.java110.order.mq.DeleteOrderInfoProducer;
			import com.java110.order.smo.IOrderServiceSMO;
			import org.apache.commons.lang.math.NumberUtils;
			import org.apache.commons.lang3.StringUtils;
			@@ -22,10 +26,7 @@
			import org.springframework.transaction.annotation.Transactional;
			import com.java110.common.util.Assert;

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

			/**
			* 订单服务业务逻辑处理实现类
			@@ -43,6 +44,9 @@

			@Autowired
			EventProperties eventProperties;

			@Autowired
			DeleteOrderInfoProducer deleteOrderInfoProducer;

			/**
			* 根据购物车ID 或者外部系统ID 或者 custId 或者 channelId 查询订单信息
			@@ -230,7 +234,8 @@
			//发布事件
			AppEventPublishing.multicastEvent(context,datasTmp,orderListTmp.getString("asyn"));
			}catch (Exception e){
			//这里补偿事物
			//这里补偿事物,这里发布广播
			compensateTransactional(datasTmp);
			throw e;
			}
			return ProtocolUtil.createResultMsg(ProtocolUtil.RETURN_MSG_SUCCESS,"成功",JSONObject.parseObject(JSONObject.toJSONString(orderList)));
			@@ -335,12 +340,82 @@
			throw new IllegalArgumentException("当前系统只支持busiOrder 节点下第一个节点包含 actionTypeCd节点和 oldOlId节点的报文："+orderInfo);
			}

			//数据分装
			Map<String,JSONArray> datasTmp = new HashMap<String, JSONArray>();
			//添加数据至 busi_order,这里生成新的boId 将需要作废的boId信息写入值busi_order_attr 中单独注册一个属性信息

			for(Map<String,String> needDeleteBoIdMap : needDeleteBoIds){
			BusiOrder busiOrder = new BusiOrder();

			String newBoId = this.queryPrimaryKey(iPrimaryKeyService,"BO_ID");

			busiOrder.setOlId(olId);
			//重新生成 boId
			busiOrder.setBoId(newBoId);
			//设置撤单，作废订单动作
			busiOrder.setActionTypeCd(ActionTypeConstant.ACTION_TYPE_CANCEL_ORDER);

			busiOrder.setRemark("撤单，作废订单处理，作废订单为"+needDeleteBoIdMap.get("boId"));

			//这里保存订单项 busiOrder
			int saveBusiOrderFlag = iOrderServiceDao.saveDataToBusiOrder(busiOrder);
			if(saveBusiOrderFlag < 1){
			throw new RuntimeException("撤单，作废订单失败，保存订单项信息失败"+JSONObject.toJSONString(busiOrder));
			}

			//将需要作废的订单boId 写入值 busi_order_attr 中属性为： 10000001

			BusiOrderAttr busiOrderAttr = new BusiOrderAttr();
			busiOrderAttr.setBoId(newBoId);
			busiOrderAttr.setAttrCd(AttrCdConstant.BUSI_ORDER_ATTR_10000001);
			busiOrderAttr.setValue(needDeleteBoIdMap.get("boId"));
			needDeleteBoIdMap.put("newBoId",newBoId);

			saveBusiOrderFlag = iOrderServiceDao.saveDataToBusiOrderAttr(busiOrderAttr);
			if(saveBusiOrderFlag < 1){
			throw new RuntimeException("撤单，作废订单失败,保存订单项信息属性失败"+JSONObject.toJSONString(busiOrderAttr));
			}

			//封装数据
			processDeleteOrderByActionTypeCd(needDeleteBoIdMap,datasTmp);

			}

			//这里补充 order_list_attr中编码为 10000002 的数据，要作废订单购物车信息，真正作废单子是以 busi_order_attr 中的boId 为主
			Assert.hasSize(datasTmp,"当前没有可作废的订单，请核实");
			//由于撤单，作废订单我们只支持一个购物车操作
			Set keys = datasTmp.keySet();
			Object key = keys.toArray()[0];
			Assert.isNull(datasTmp.get(key).getJSONObject(0),"olId","数据错误，需要作废的订单的第一个节点为空，或不包含olId节点，请核查"+datasTmp);
			String oldOlId = datasTmp.get(key).getJSONObject(0).getString("olId");


			OrderListAttr orderListAttr = new OrderListAttr();
			orderListAttr.setOlId(olId);
			orderListAttr.setAttrCd(AttrCdConstant.ORDER_LIST_ATTR_10000002);
			orderListAttr.setValue(oldOlId);
			saveOrderListFlag = iOrderServiceDao.saveDataToOrderListAttr(orderListAttr);
			if(saveOrderListFlag < 1){
			throw new RuntimeException("保存购物车属性信息失败"+JSONObject.toJSONString(orderListAttr));
			}



			return null;

			//创建上下文对象
			AppContext context = createApplicationContext();

			prepareContext(context, datasTmp);
			try {
			//发布事件
			AppEventPublishing.multicastEvent(context,datasTmp,orderListTmp.getString("asyn"));
			}catch (Exception e){
			//这里补偿事物
			compensateTransactional(datasTmp);
			throw e;
			}
			return ProtocolUtil.createResultMsg(ProtocolUtil.RETURN_MSG_SUCCESS,"成功",JSONObject.parseObject(JSONObject.toJSONString(orderList)));

			}

			/**
			@@ -397,6 +472,100 @@

			}


			/**
			*
			* oldBoIdMap.put("actionTypeCd","");
			*
			* oldBoIdMap.put("boId",busiOrderTmps.getJSONObject(busiOrderIndex).getString("oldBoId"));
			* oldBoIdMap.put("olId","");
			* @param needDeleteBoIdMap
			*
			*/
			private void processDeleteOrderByActionTypeCd(Map<String,String> needDeleteBoIdMap,Map<String,JSONArray> datasTmp){

			Assert.isNull(datasTmp,"processDeleteOrderByActionTypeCd 方法的参数 datasTmp 为空，");

			// 如果这两个中有一个为空，则从库中查询
			if(StringUtils.isBlank(needDeleteBoIdMap.get("newBoId")) \|\| StringUtils.isBlank(needDeleteBoIdMap.get("actionTypeCd"))){
			BusiOrder busiOrderTmp = new BusiOrder();
			busiOrderTmp.setBoId(needDeleteBoIdMap.get("boId"));
			//这里只有一条其他，否则抛出异常
			List<BusiOrder> oldBusiOrders = iOrderServiceDao.queryBusiOrderAndAttr(busiOrderTmp);

			if(oldBusiOrders == null \|\| oldBusiOrders.size() != 1){
			throw new IllegalArgumentException("当前[boId="+needDeleteBoIdMap.get("boId")+"] 数据在busi_order表中不存在，请处理，很有可能是入参错误");
			}

			//回写数据

			needDeleteBoIdMap.put("olId",oldBusiOrders.get(0).getOlId());
			needDeleteBoIdMap.put("actionTypeCd",oldBusiOrders.get(0).getActionTypeCd()+ CommonConstant.SUFFIX_DELETE_ORDER);
			}

			String actionTypeCd = needDeleteBoIdMap.get("actionTypeCd");

			JSONArray dataJsonTmp = null;
			if(!datasTmp.containsKey(actionTypeCd)){
			dataJsonTmp = new JSONArray();
			}else{
			dataJsonTmp = datasTmp.get(actionTypeCd);
			}
			dataJsonTmp.add(JSONObject.parseObject(JSONObject.toJSONString(needDeleteBoIdMap)));
			datasTmp.put(actionTypeCd,dataJsonTmp);

			//deleteOrderInfoProducer.send(datasTmp.toString());
			}


			/**
			* 补偿事物，这里不用手工作废购物车信息，事物会自动回退掉，这里这需要手工给其他的系统发布事物回退
			*
			* { 'data': [

			{
			'boId': '222222',
			'actionTypeCd': 'C1',
			'oldBoId':'11111'
			},
			{
			'boId': '222222',
			'actionTypeCd': 'M1',
			'oldBoId':'11111'
			},
			{
			'boId': '222222',
			'actionTypeCd': 'C1',
			'oldBoId':'11111'
			}
			]
			}
			* @param datasTmp {C1={'data':[{}]}}
			*/
			private void compensateTransactional(Map<String,JSONArray> datasTmp){

			Set<String> keys = datasTmp.keySet();

			JSONArray compensateDatas = new JSONArray();

			JSONObject compensateBoId = null;
			for(String key : keys){
			JSONArray datas = datasTmp.get(key);

			for(int dataIndex = 0 ; dataIndex <datas.size() ; dataIndex++){
			compensateBoId.put("boId",datas.getJSONObject(dataIndex).getString("boId"));
			compensateBoId.put("actionTypeCd",key);
			compensateDatas.add(compensateBoId);
			}
			}

			JSONObject compensateData = new JSONObject();

			compensateData.put("data",compensateDatas);

			deleteOrderInfoProducer.send(datasTmp.toString());
			}

			public IPrimaryKeyService getiPrimaryKeyService() {
			return iPrimaryKeyService;
			}