package grand;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import book.BookName;
import book.FlowTable;
import book.FreezeCondition;
import book.QtyCommand;
import book.RecordOperator;
import book.rebate.BookCommand;
import book.rebate.BookCommandBucket;
import foundation.action.ActionBucket;
import foundation.action.ActionMeta;
import foundation.action.ActionProvider;
import foundation.action.WorkStep;
import foundation.action.WorkflowDispatcher;
import foundation.capacity.ActorTarget;
import foundation.code.CodeEngine;
import foundation.dao.DataPackage;
import foundation.dao.DataSource;
import foundation.dao.Filter;
import foundation.dao.PackageItem;
import foundation.dao.PackageState;
import foundation.dao.Settings;
import foundation.dao.bizlogic.DocDescription;
import foundation.dao.bizlogic.IRequest;
import foundation.dao.bizlogic.ResponseType;
import foundation.data.entity.Entity;
import foundation.data.entity.EntitySet;
import foundation.data.mapping.FieldMapping;
import foundation.data.mapping.Mappings;
import foundation.data.object.DataObject;
import foundation.data.object.EntitySaver;
import foundation.icall.ICall;
import foundation.icall.ICallCenter;
import foundation.icall.RemoteContext;
import foundation.icall.callout.HttpServerSource;
import foundation.icall.callout.JSONResponse;
import foundation.json.JArrayReader;
import foundation.json.JSONBuilder;
import foundation.json.JSONReader;
import foundation.persist.NamedSQL;
import foundation.persist.SQLRunner;
import foundation.send.mail.MailCenter;
import foundation.user.OnlineUser;
import foundation.util.ID;
import foundation.util.Util;
import policy.OrderLineType;
import policy.rule.OrderCalculator;

public class OrderHandler extends ActionProvider {
	
	@Override
	protected void publishMethod() {
		//1. 订单默认值
		addMethod("setDefaultValues");
		
		//2. 订单看板
		addMethod("createBoard");
		
		//3. 保存校验
		addMethod("saveValidate");
		
		//4. 提交校验
		addMethod("commitValidate");
		
		//5. 补充OA-NC字段
		addMethod("writeOANCValues");
		
		//6. 检查OA-NC字段
		addMethod("checkOANCValues");
		
		//7.1 批量推送OA
		addMethod("syncOAOrder");
		
		//7.2发送到OA
		addMethod("sendToOA");

		//8. OA订单回写
		addMethod("callbackOA");
		
		//9. 创建发货单
		addMethod("createDelivery");
		
		//10. 更新发货数量
		addMethod("updateQtyDelivery");
		
		//11. 更新收货数量
		addMethod("updateQtyReceived");

		//12. 更新植入单销售人员信息
		addMethod("updateImplantPositionHierarchy");

		//13. 订单整单关闭
		addMethod("orderClose");

		//14. 订单行关闭
		addMethod("orderDetailClose");

		//15. 订单行撤销关闭
		addMethod("orderDetailCancelClose");
	}

	public void setDefaultValues() throws Exception {
		DataPackage dataPackage = dataReader.getDataPackage();
		Entity entity = dataPackage.getMasterEntity(DataSource.New);
		
		if (entity == null) {
			dataPackage.createDefaultOneData();
			entity = dataPackage.getMasterEntity(DataSource.New);
			dataPackage.setResultData(DataSource.New);
		}
		
		OnlineUser user = OnlineUser.getInstance();
		ActorTarget actor =  user.getCurrentActor();
		Entity accountEntity =  actor.getAccount();
		
		//1. 设置默认主体公司、BU
		entity.set("company_id", actor.getCompanyId());
		entity.set("company_name", actor.getCompanyName());
		entity.set("bu_id", actor.getBuId());
		entity.set("bu_name", actor.getBUName());
		
		//2. 设置单据日期、客户（开户）编码和名称,结算方式
		entity.set("doc_date", new Date());
		entity.set("customer_id", actor.getAccountId());
		entity.set("customer_code", actor.getAccountCode());
		entity.set("customer_name", actor.getAccountName());
		
		if (accountEntity != null ) {
			entity.set("settlement", accountEntity.getString("settlement"));
		}

		//3. 设置默认收货地址
		dataWriter.setDataPackage(dataPackage);
	}
	
	public void createBoard() throws Exception {
		
	}
	
	public void saveValidate() throws Exception {
		
	}
	
	public void commitValidate() throws Exception {
		
	}
	
	public void writeOANCValues() throws Exception {
		//1. 获取订单头
		DataPackage dataPackage = dataReader.getDataPackage();
		Entity master = dataPackage.getMasterEntity();
		String accountId = master.getString("customer_id");
		String customerOrgId = master.getString("org_id");
		
		//2. 获取OA和NC信息
		DataObject customerObject = DataObject.getInstance("md_org");
		Entity customer = customerObject.getTableEntity(customerOrgId);
		
		NamedSQL namedSQL = NamedSQL.getInstance("getCustomerSalesEmployee");
		Filter filter = new Filter();
		filter.add("md_org_account_position.parent_id", accountId);

		String positionId = dataReader.getString("position_id");
		if (!Util.isEmpty(positionId)) {
			filter.add("md_org_account_position.position_id", positionId);
		}
		
		String employeeId = dataReader.getString("employee_id");
		if (!Util.isEmpty(employeeId)) {
			filter.add("md_position_employee.employee_id", employeeId);
		}
		
		namedSQL.setFilter(filter);
		EntitySet employees = SQLRunner.getEntitySet(namedSQL);
		
		//3. 填写OA和NC信息
		if (employees == null || employees.size() != 1 ) {
			return;
		}
		
		Entity  employee = employees.getEntity(0);
		DataObject dataObject = dataPackage.getMasterDataObject();
		EntitySaver saver = dataObject.createEntitySaver(master);
		saver.set("nc_company_id", employee.getValue("nc_org_id"));
		saver.set("nc_company_code", employee.getValue("nc_org_code"));
		saver.set("nc_region_id", employee.getValue("nc_region_id"));
		saver.set("nc_region_code", employee.getValue("nc_region_code"));
		saver.set("nc_region_name", employee.getValue("nc_region_name"));
		saver.set("nc_area_id", employee.getValue("nc_area_id"));
		saver.set("nc_area_code", employee.getValue("nc_area_code"));
		saver.set("nc_area_name", employee.getValue("nc_area_name"));
		saver.set("nc_customer_id", customer.getValue("nc_id"));
		saver.set("nc_customer_code", customer.getValue("ncc_code"));
		saver.set("oa_department_id", employee.getValue("oa_department_id"));
		saver.set("oa_department_name", employee.getValue("oa_department_name"));
		saver.set("oa_employee_id", employee.getValue("id"));
		saver.set("oa_employee_code", employee.getValue("code"));
		saver.set("oa_employee_name", employee.getValue("name"));
		saver.update();
	}
	
	public void checkOANCValues() throws Exception {
		DataPackage dataPackage = dataReader.getDataPackage();
		Entity master = dataPackage.getMasterEntity();
		boolean success = true;
		
		if (master.existsEmptyValue("nc_company_id", "nc_company_code")) {
			success = false;
			dataWriter.reportOneError("订单检查", "公司主体（NC）信息缺少");
		}
		
		if (master.existsEmptyValue("nc_region_id", "nc_region_code", "nc_region_name")) {
			success = false;
			dataWriter.reportOneError("订单检查", "销售大区（NC）信息缺少");
		}
		
		if (master.existsEmptyValue("nc_area_id", "nc_area_code", "nc_area_name")) {
			success = false;
			dataWriter.reportOneError("订单检查", "销售区域（NC）信息缺少");
		}
		
		if (master.existsEmptyValue("nc_customer_id", "nc_customer_code")) {
			success = false;
			dataWriter.reportOneError("订单检查", "客户（NC）信息缺少");
		}
		
		if (master.isEmptyValue("oa_department_id")) {
			success = false;
			dataWriter.reportOneError("订单检查", "部门（OA）信息缺少");
		}
		
		if (master.existsEmptyValue("oa_employee_id", "oa_employee_code", "oa_employee_name")) {
			success = false;
			dataWriter.reportOneError("订单检查", "部门（OA）信息缺少");
		}
		
		if (!success) {
			 task.terminate();
		 }
	}
	
	public void sendToOA() throws Exception {
		DataPackage dataPackage = dataReader.getDataPackage();
		Entity master = dataPackage.getMasterEntity();
		
		if (master == null) {
			logger.debug("订单不存在，跳过发送OA步骤: {}", dataPackage.getMasterId());
			return;
		}

		RemoteContext remoteContext = context.getContext(RemoteContext.class);
		//1. 回写OA要货单号
		ICall iCall =  ICall.getInstance("oa_dms_order_callback");
		ICallCenter iCallCenter = ICallCenter.getInstance();
		iCallCenter.callRemote(context, iCall);
		
		//2. 推送OA
		sendOneOrderToOA(dataPackage, remoteContext);
	}

	public void syncOAOrder() throws Exception {
		ICallCenter iCallCenter = ICallCenter.getInstance();
		ICall iCall =  ICall.getInstance("oa_dms_order_send");
		RemoteContext remoteContext = new RemoteContext(iCall);
		 
		//1.获取未推送OA的生效订单
		DataObject dataObject = DataObject.getInstance("so_order");
		Filter filter = new Filter();
		
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.append(Util.quotedStr(OASyncState.Success.getName())).append(",");
		stringBuilder.append(Util.quotedStr(OASyncState.Syncing.getName()));
		String oaSyncStateFilter = "(" + stringBuilder.toString() + ")";
		
		filter.add("ifnull(oa_sync_state,'')", " not in", oaSyncStateFilter);
		filter.add("state_code", "open");
		EntitySet entitySet = dataObject.getTableEntitySet(filter);	
		
		DataPackage dataPackage = DataPackage.getInstance("so_order");
		
		//2. 拼接参数，推送OA
		for (Entity entity: entitySet) {
			String orderId = entity.getId();
			dataPackage.setState(new PackageState());
			dataPackage.setMasterId(orderId);
			dataPackage.loadOneDataFromDB();
			sendOneOrderToOA(dataPackage, remoteContext);
			
			//3. 回写OA要货单号
			iCall =  ICall.getInstance("oa_dms_order_callback");
			iCallCenter.callRemote(context, iCall);
		}
	}

	private void sendOneOrderToOA(DataPackage dataPackage, RemoteContext remoteContext) throws Exception {
		Entity master = dataPackage.getMasterEntity();
		
		OrderState  orderState = OrderState.parse(master.getString("state_code"));
		if (OrderState.Open != orderState) {
			return ;
		}
		
		ICall iCall = remoteContext.getICall();
		HttpServerSource source = iCall.remoteSource();
		source.login(context, iCall);
		
		Mappings headMappings = remoteContext.getMappings("so_order");
		String headData = getSendOrderHeadToOA(dataPackage, headMappings);
		logger.debug("send OA head: {}", headData);

		Mappings detailMappings = remoteContext.getMappings("so_order_detail");
		String detailData = getSendOrderDetailToOA(dataPackage, detailMappings);
		logger.debug("send OA details: {}", detailData);
		
		//1. 标记推送OA
		boolean sendOAActive = Settings.getBoolean("OrderSendToOA", false);
		OASyncState sendOAState = OASyncState.parse(master.getString("oa_sync_state"));
		
		//2. 创建请求
		IRequest request = remoteContext.createRequest("api/workflow/paService/doCreateRequest");
		request.addFormData("workflowId", "164964");
		request.addFormData("mainData", headData);
		request.addFormData("requestName", master.getId());
		request.addFormData("detailData", detailData);
		request.setDocDescription(new DocDescription(master.getId(), master.getString("code")));
		SQLRunner.beginTrans();
		
		//3. 获取返回日志
		logger.info("订单状态：{}", sendOAState.getName());
		if ((!sendOAActive) || sendOAState == OASyncState.Success || sendOAState == OASyncState.Syncing) {
			logger.info("订单推送功能未启用|已推送OA，本次OA不会收到此订单");
			SQLRunner.commit();
			return;
		}
		else {
			EntitySaver saver = dataPackage.createMasterEntitySaver();
			int sendOaCount = master.getInteger("send_oa_count", 0);
			sendOaCount++;
			saver.set("oa_sync_state", OASyncState.Syncing.getName());
			saver.set("send_oa_count", sendOaCount);
			saver.update();
			logger.info("订单推送OA");
		}
		
		//4. 发送请求
		JSONResponse response = remoteContext.post(request, ResponseType.JSON);

		SQLRunner.commit();
		//5. 结果返回
		if (response == null || response.hasErrors()) {
			MailCenter mailCenter = MailCenter.getInstance();
			mailCenter.sendMailByDataPackage(dataPackage, "orderSendError");

			logger.debug("send OA result: null");
		}
		else {
			String responseValue = response.toString();
			logger.debug("send OA result: {}", responseValue);
		}
	}

	private String getSendOrderHeadToOA(DataPackage dataPackage, Mappings mappings) throws Exception {
		String value;
		Entity master = dataPackage.getMasterEntity();
		String orgId = master.getString("org_id");
		DataObject orgObject = DataObject.getInstance("md_org");
		Entity orgEntity = orgObject.getTableEntity(orgId);
		JSONBuilder headerBuilder = new JSONBuilder();
		headerBuilder.setEncodeActive(false);
		
		headerBuilder.beginArray();
		
		for (FieldMapping mapping: mappings) {
			if (!mapping.isActive()) {
				logger.debug("跳过字段：{} --> {}", mapping.getFromName(), mapping.getToName());
				continue;
			}
			
			String fromName = mapping.getFromName();
			if (fromName.equalsIgnoreCase("receiveman") 
					|| fromName.equalsIgnoreCase("receivephone") 
					|| fromName.equalsIgnoreCase("receiveaddress") ) {
				value = getValue(orgEntity, mapping.getToName());
			} else {
				value = getValue(master, mapping.getToName());
			}
			
			headerBuilder.beginObject();
			headerBuilder.write("fieldName", mapping.getFromName());
			headerBuilder.write("fieldValue", value);
			headerBuilder.endObject();
		}
		
		headerBuilder.endArray();
		
		return headerBuilder.toString();
	}

	private String getSendOrderDetailToOA(DataPackage dataPackage, Mappings mappings) throws Exception {
		String value;
		dataPackage.loadOneDataFromDB();
		EntitySet entitySet = dataPackage.getItemEntitySet("so_order_detail");		
		
		JSONBuilder detailBuilder = new JSONBuilder();
		detailBuilder.setEncodeActive(false);
		detailBuilder.setLowerNameActive(false);
		int index = 0;
		
		detailBuilder.beginArray();
		detailBuilder.beginObject();
		detailBuilder.write("tableDBName", "formtable_main_1549_dt1");
		detailBuilder.beginArray("workflowRequestTableRecords");
		
		for (Entity detail: entitySet) {
			detailBuilder.beginObject();
			
			detailBuilder.write("recordOrder", index++);
			detailBuilder.beginArray("workflowRequestTableFields");
			
			for (FieldMapping mapping: mappings) {
				value = getValue(detail, mapping.getToName());
				
				detailBuilder.beginObject();
				detailBuilder.write("fieldName", mapping.getFromName());
				detailBuilder.write("fieldValue", value);
				detailBuilder.endObject();
			}
			
			detailBuilder.endArray();
			detailBuilder.endObject();
		}
		
		detailBuilder.endArray();
		detailBuilder.endObject();
		detailBuilder.endArray();

		return detailBuilder.toString();
	}
	
	public void callbackOA() throws Exception {
		DataObject dataObject = DataObject.getInstance("sys_interface_stamp");
		Entity entity;
		EntitySaver entitySaver;
		String value;
		
		RemoteContext remoteContext = context.getContext(RemoteContext.class);
		IRequest request = remoteContext.createRequest("api/workflow/paService/getMyWorkflowRequestList");
		
		//1. 设置请求参数
		Mappings mappings = remoteContext.getMappings("so_order_callback");
		for (FieldMapping mapping: mappings) {
			if (!mapping.isActive()) {
				logger.debug("跳过字段：{} --> {}", mapping.getFromName(), mapping.getToName());
				continue;
			}
			
			request.addFormData(mapping.getFromName(), mapping.getToName());
			
		}
		
		//2.  获取上次请求的时间戳
		NamedSQL namedSQL = NamedSQL.getInstance("getLastInterfaceStamp");
		namedSQL.setParam("interfaceId", remoteContext.getICall().getId());
		Entity lastStamp = namedSQL.getEntity();
		
		//3.  过滤条件
		mappings = remoteContext.getMappings("so_order_callback_conditions");
		JSONBuilder conditionsBuilder = new JSONBuilder();
		conditionsBuilder.setEncodeActive(false);
		
		conditionsBuilder.beginObject();
		for (FieldMapping mapping: mappings) {
			if (!mapping.isActive()) {
				logger.debug("跳过字段：{} --> {}", mapping.getFromName(), mapping.getToName());
				continue;
			}
			
			value = getValue(lastStamp, mapping.getToName());
			conditionsBuilder.write(mapping.getFromName(), value);
		}
		conditionsBuilder.endObject();
		
		String conditions = conditionsBuilder.toString();
		logger.info("OA callback conditions： {}", conditions);
		request.addFormData("conditions", conditions);

		//4. 发送请求
		boolean sendOAActive = Settings.getBoolean("OrderSendToOA", false);
		if (!sendOAActive) {
			dataWriter.reportOneMessage("从OA回写订单", "订单推送功能未启用，跳过OA订单回写");
			logger.info("订单推送功能未启用，跳过OA订单回写");
			return;
		}
		else {
			logger.info("订单推送OA");
		}
		
		JSONResponse response = remoteContext.post(request, ResponseType.JSON);
		JArrayReader jarray = response.parseJArrayReader();
		
		//5.  回写订单
		dataObject = DataObject.getInstance("so_order");
		for (JSONReader json : jarray) {
			String orderId = json.getString("requestName");
			String requestId = json.getString("requestId");
			entity = dataObject.getTableEntity(orderId);

			if (entity == null ) {
				continue;
			}
			
			entitySaver = dataObject.createEntitySaver(entity);
			entitySaver.set("oa_code", requestId);
			
			if(Util.isEmpty(requestId)) {
				entitySaver.set("oa_sync_state", OASyncState.Success.getName());
			}
			entitySaver.update();
		}
	}	
	
	public void createDelivery() throws Exception {
		String orderNo = dataReader.getString("order_no");
		DateFormat dateFormat = new SimpleDateFormat("YYYY-MM-dd");
		OnlineUser user = OnlineUser.getInstance();
		
		//1. 获取订单
		DataPackage dataPackage = DataPackage.getInstance("so_order");
		dataPackage.setFilter(new Filter("code", orderNo));
		dataPackage.loadOneDataFromDB();
		DataObject dataObject = DataObject.getInstance("so_delivery");
		EntitySaver saver = dataObject.createEntitySaver();
		
		//2. 创建发货单头
		String deliveryId = ID.newValue();
		Entity orderMaster = dataPackage.getMasterEntity(DataSource.DB);
		
		String deliveryCode = CodeEngine.nextval("Code-Delivery", null);
	
		saver.set("id", deliveryId);
		saver.set("company_name", orderMaster.getValue("company_name"));
		saver.set("bu_name", orderMaster.getValue("bu_name"));
		saver.set("state_code", "Unreceived");
		saver.set("state_name", "未收货");
		saver.set("code", deliveryCode);
		saver.set("order_id", orderMaster.getId());
		saver.set("order_code", orderMaster.getString("code"));
		saver.set("doc_date", orderMaster.getValue("doc_date"));
		saver.set("doc_type", "普通销售出库");
		saver.set("shipto_date", dateFormat.format(new Date()));
		saver.set("plan_shipto_date", orderMaster.getValue("date_plan_ship_to"));
		saver.set("customer_id", orderMaster.getValue("customer_id"));
		saver.set("customer_code", orderMaster.getValue("customer_code"));
		saver.set("customer_code_ncc", orderMaster.getValue("nc_customer_code"));
		saver.set("customer_name", orderMaster.getValue("customer_name"));
		saver.set("company_name", orderMaster.getValue("company_name"));
		saver.set("shipto_address", orderMaster.getValue("shipto_address"));
		saver.set("shipto_contact", orderMaster.getValue("shipto_contact"));
		saver.set("shipto_phone", orderMaster.getValue("shipto_phone"));
		saver.set("supplier_code", orderMaster.getValue("company_id"));
		saver.set("supplier_name", orderMaster.getValue("company_name"));
		saver.set("transport_type", orderMaster.getValue("plan_shipto_type"));
		String currentMills = String.valueOf(System.currentTimeMillis());
		saver.set("express_code", "SF027" + currentMills.substring(currentMills.length() - 9));
		saver.set("express_company", "顺丰");
		saver.set("creator_id", user.getCode());
		saver.set("creator_name", user.getName());
		saver.insert();
			
		//3. 创建发货单明细
		EntitySet orderDetails = dataPackage.getItemEntitySet("so_order_detail", DataSource.DB);
		dataObject = DataObject.getInstance("so_delivery_detail");
		saver = dataObject.createEntitySaver();
		
		for (Entity orderDetail : orderDetails) {		
			saver.set("id", ID.newValue());
			saver.set("parent_id", deliveryId);
			saver.set("order_id", orderMaster.getValue("id"));
			saver.set("order_detail_id", orderDetail.getValue("id"));
			saver.set("order_code", orderMaster.getValue("code"));
			saver.set("order_type_code", orderMaster.getValue("type_code"));
			saver.set("order_right_code", "normal");
			saver.set("stock_type_code", "Standard");
			saver.set("product_id", orderDetail.getValue("sku_id"));
			saver.set("product_code", orderDetail.getValue("product_code"));
			saver.set("product_name", orderDetail.getValue("product_name"));
			saver.set("material_code", orderDetail.getValue("product_code"));
			saver.set("material_name", orderDetail.getValue("product_name"));
			saver.set("spec", orderDetail.getValue("spec"));
			saver.set("unit", orderDetail.getValue("unit"));
			saver.set("batch_no", "N/A");
			saver.set("valid_from", "2023-07-28");
			saver.set("valid_to", "2025-07-28");
			saver.set("batch_sn","");
			saver.set("qty", orderDetail.getValue("qty"));
			
			if ("gift".equals(orderDetail.getValue("type_code"))) {
				saver.set("is_money_free", 1);
			}
			else {
				saver.set("is_money_free", 0);
			}
			
			saver.set("shipto_address", orderMaster.getValue("shipto_address_fullname"));
			saver.set("shipto_contact", orderMaster.getValue("shipto_contact"));
			saver.set("shipto_phone", orderMaster.getValue("shipto_phone"));
			saver.set("voucher_no", orderDetail.getValue("rebate_code"));
			saver.set("manufacturer", "");
			saver.insert();
		}
		 
		dataObject = DataObject.getInstance("so_order");
		saver = dataObject.createEntitySaver(orderMaster);
		int deliveryQty = orderMaster.getInt("qty_delivery") + orderMaster.getInt("qty_total"); 
		saver.set("qty_delivery", deliveryQty);
		saver.set("state_code", "Whole");
		saver.set("state_delivery_code", "Whole");
		saver.set("state_delivery_name", "全部发货");
		saver.set("state_name", "已发货");
		saver.update();
	}
	
	public void updateQtyDelivery() throws Exception {
		String orderId = dataReader.getString("order_id");
		
		//1. 获取发货数量
		DataObject dataObject = DataObject.getInstance("so_delivery_detail");		
		Entity qtyDeliverySumEntity = dataObject.getSummary("qty", new Filter("order_id", orderId));
		
		//2. 获取订单
		DataPackage dataPackage = DataPackage.getInstance("so_order");
		dataPackage.setFilter(new Filter("id", orderId));
		dataPackage.loadOneDataFromDB();
		Entity orderMaster = dataPackage.getMasterEntity();
		
		//3. 更新订单发货数量
		EntitySaver saver = dataObject.createEntitySaver(orderMaster);		
		saver.set("qty_delivery", qtyDeliverySumEntity.getValue("qty_sum"));		
		saver.update();
	}

	public void updateQtyReceived() throws Exception {
		String deliveryId = dataReader.getString("id");
		String orderId;
		Entity orderEntity;
		int deliveryQty = 0, receivedQty = 0, receivingQty = 0, orderQty = 0;
		
		if (Util.isEmpty(deliveryId)) {
			dataWriter.reportOneMessage("订单收货", "未获取到发货单信息，无法收货");
			return;
		}
		
		//1. 获取订单收货数量
		NamedSQL namedSQL = NamedSQL.getInstance("getQtyReceived");
		namedSQL.setParam("deliveryId", deliveryId);
		EntitySet qtyReceivedEntitySet = SQLRunner.getEntitySet(namedSQL);
		
		//2. 回写订单		
		DataObject dataObject = DataObject.getInstance("so_order");
		EntitySaver saver;
		
		SQLRunner.beginTrans();
		for(Entity entity: qtyReceivedEntitySet) {
			orderId = entity.getString("order_id");
			receivingQty = entity.getInt("qty_received");
			
			if (Util.isEmpty(orderId)) {
				dataWriter.reportOneMessage("订单收货", "未获取到订单信息，无法收货");
				return;
			}
			
			orderEntity = dataObject.getTableEntity(orderId);			
			orderQty = orderEntity.getInt("qty_total");
			deliveryQty = orderEntity.getInt("qty_delivery"); 
			receivedQty = orderEntity.getInt("qty_received");			
			receivedQty = receivedQty + receivingQty;

			
			saver = dataObject.createEntitySaver(orderEntity);
			if (receivedQty > deliveryQty) {
				dataWriter.reportOneMessage("订单收货", "收货数量大于发货数量，请勿重复收货");
				SQLRunner.rollback();
				return;
			}
			else if (receivedQty > orderQty) {
				dataWriter.reportOneMessage("订单收货", "收货数量大于订单数量，请勿重复收货");
				SQLRunner.rollback();
				return;
			}
			else if(receivedQty == orderQty){
				saver.set("qty_received",receivedQty);
			}
			else if(receivedQty < orderQty) {
				saver.set("qty_received",receivedQty);
			}
			
			saver.update();
		}
		
		SQLRunner.commit();		
	}
	
	private String getValue(Entity entity, String fieldName) {
		if (Util.isEmpty(fieldName)) {
			return "";
		}
		
		//1. 如果是常数，直接返回
		if (!fieldName.startsWith("@{")) {
			return fieldName;
		}
		
		//2. 如果是字段名称，获取 Entity 字段数据
		fieldName = fieldName.substring(2, fieldName.length() - 1);
		
		String result = onGetEntityValue(fieldName, entity);
		
		if (result != null) {
			return result;
		}
		
		return entity.getString(fieldName, "");
	}

	private String onGetEntityValue(String fieldName, Entity entity) {
		if ("doc_date".equals(fieldName)) {
			Date date = entity.getDate("doc_date", null);
			String result = Util.DataTimeToString(date, "yyyy-MM-dd");
			
			if (result == null) {
				result = "";
			}
			
			return result;
		}
		else if ("rate_discount".equals(fieldName)) {
			BigDecimal amtNet = entity.getBigDecimal("amt_net", BigDecimal.ZERO);
			BigDecimal listAmt = entity.getBigDecimal("amt_list", BigDecimal.ZERO);
			BigDecimal rate = OrderCalculator.divide(amtNet, listAmt, 8);
			rate = rate.multiply(BigDecimal.valueOf(100));
			rate.setScale(6, RoundingMode.HALF_UP);
			return rate.toPlainString(); 
		}
		else if ("is_gift".equals(fieldName)) {
			OrderLineType lineType = OrderLineType.parse(entity.getString("type_code"));
			String result = "0";
			
			if (OrderLineType.OnsiteQty == lineType || OrderLineType.RebateQty == lineType) {
				result = "1";
			}
			
			return result;
		}
		else if ("amt_list".equals(fieldName)) {
			OrderLineType lineType = OrderLineType.parse(entity.getString("type_code"));
			BigDecimal result = entity.getBigDecimal("amt_list", BigDecimal.ZERO);
			
			if (OrderLineType.OnsiteQty == lineType || OrderLineType.RebateQty == lineType) {
				result = BigDecimal.ZERO;
			}
			
			return result.toString();
		}
		
		return null;
	}

	public void updateImplantPositionHierarchy() throws Exception {
		DataPackage dataPackage = dataReader.getDataPackage();
		DataObject dateObject = DataObject.getInstance("so_implant");
		Entity masterEntity = dataPackage.getMasterEntity();
		EntitySaver saver = dateObject.createEntitySaver(masterEntity);
		
		NamedSQL namedSQL = NamedSQL.getInstance("getImplantPositionHierarchy");
		String hospitalId = masterEntity.getString("hospital_id");
		namedSQL.setParam("hospitalId", hospitalId);
		Entity hierarchyEntity = SQLRunner.getEntity(namedSQL);
		
		String positionId = hierarchyEntity.getString("position_id");
		String areaPosition = hierarchyEntity.getString("level3");
		String regionPosition = hierarchyEntity.getString("level2");
		if (areaPosition == null || areaPosition.isEmpty()) {
			areaPosition = hierarchyEntity.getString("level2");
			regionPosition = hierarchyEntity.getString("level1");
		}

		namedSQL = NamedSQL.getInstance("getPositionEmployee");
		namedSQL.setParam("positionId", regionPosition);
		Entity positionEntity = SQLRunner.getEntity(namedSQL);
		saver.set("sale_region", positionEntity.getString("position_name"));
		saver.set("sale_region_employee_code", positionEntity.getString("employee_code"));
		saver.set("sale_region_employee_name", positionEntity.getString("employee_name"));
		
		namedSQL.setParam("positionId", areaPosition);
		positionEntity = SQLRunner.getEntity(namedSQL);
		saver.set("sale_area", positionEntity.getString("position_name"));
		saver.set("sale_area_employee_code", positionEntity.getString("employee_code"));
		saver.set("sale_area_employee_name", positionEntity.getString("employee_name"));
		
		namedSQL.setParam("positionId", positionId);
		positionEntity = SQLRunner.getEntity(namedSQL);
		saver.set("sale_position_employee_code", positionEntity.getString("employee_code"));
		saver.set("sale_position_employee_name", positionEntity.getString("employee_name"));
		saver.set("sale_position_id", positionEntity.getString("position_id"));
		
		saver.update();
	}
	
	public void orderClose() throws Exception {
		DataPackage dataPackage  = dataReader.getDataPackage();
		Entity master = dataPackage.getMasterEntity(DataSource.Request);
		master = dataPackage.getMasterEntity();
		
		EntitySet details = dataPackage.getItemEntitySet("so_order_detail",DataSource.Request);
		String orderId = master.getId();
		
		//1. 检查头状态
		SQLRunner.beginTrans();
		OrderState orderState = loadOrderState(master);
		
		if(!OrderState.Open.equals(orderState)) {
			dataWriter.reportOneError("orderLineClose", "当前状态不允许整单订单：" + orderState.getName());
			SQLRunner.commit();
			return ;
		} 

		try {
			DataObject dataObject = dataPackage.getDetailDataObject();
			EntitySaver entitySaver; String detailCloseReason;
			BigDecimal orderCloseRebateAmt = BigDecimal.ZERO;
			BigDecimal orderCloseQty = BigDecimal.ZERO;
			
			for (Entity detail : details) {
				String detailId = detail.getId();
				detailCloseReason = detail.getString("close_reason", "");
				//2.1 关闭明细行
				entitySaver = dataObject.createEntitySaver(detailId);
				BigDecimal lineCloseQty = detail.getBigDecimal("qty_close", BigDecimal.ZERO);
				BigDecimal lineRebateCloseAmt = detail.getBigDecimal("amt_rebate_close", BigDecimal.ZERO);
				BigDecimal qtyRebateClose = detail.getBigDecimal("qty_rebate_close", BigDecimal.ZERO);
				orderCloseQty = orderCloseQty.add(lineCloseQty);
				
				//2.2 关闭积分，数量校验
				orderCloseRebateAmt = orderCloseRebateAmt.add(lineRebateCloseAmt);

				if (checkQty(detailId, lineCloseQty) || checkRebateAmt(orderId, orderCloseRebateAmt)) {
					dataWriter.reportOneError("orderLineClose", "关闭数量/金额超过行数量/金额，不允许关闭");
					SQLRunner.rollback();
					return ;
				}

				entitySaver.set("amt_rebate_close", lineRebateCloseAmt);
				entitySaver.set("qty_close", lineCloseQty);
				entitySaver.set("line_state_code", detail.getString("line_state_code"));
				entitySaver.set("qty_rebate_close", qtyRebateClose);
				entitySaver.set("close_reason", detailCloseReason);
				
				if (!Util.isEmpty(detail.getString("todate_close"))) {
					entitySaver.set("todate_close", detail.getValue("todate_close"));
				}
		
				entitySaver.update();
					
				//3.记账
				writerCloseBook(detail, "order.line.rebate.qty.close",detailId, BigDecimal.ZERO.compareTo(qtyRebateClose) < 0);
				writerCloseBook(detail, "order.line.rebate.amt.close",detailId, BigDecimal.ZERO.compareTo(lineRebateCloseAmt) < 0);
				
			}
			//4.回写头状态
			master.set("qty_close", orderCloseQty);
			dataObject = DataObject.getInstance("so_order");
			dataObject.updateEntity(master);
			
			orderState = loadOrderState(master);
		}
		catch (Exception e) {
			dataWriter.reportOneError("orderLineClose", "订单行关闭失败");
			e.printStackTrace();
			SQLRunner.rollback();
		}
		SQLRunner.commit();
		dataWriter.addValue("订单行关闭成功");
	}
	
	public void orderDetailClose() throws Exception {
		String detailId = dataReader.getString("id");
		DataObject dataObject = DataObject.getInstance("so_order_detail");
		Entity detailEntity = dataObject.getTableEntity(detailId);
		String orderId = detailEntity.getString("parent_id");
		dataObject = DataObject.getInstance("so_order");
		Entity masterEntity = dataObject.getTableEntity(orderId);
		
		
		SQLRunner.beginTrans();
		//1. 检查头状态
		OrderState orderState = loadOrderState(masterEntity);
		
		if(!(orderState.equals(OrderState.Partial) || OrderState.Open.equals(orderState))) {
			dataWriter.reportOneError("orderLineClose", "当前状态不允许关闭订单：" + orderState.getName());
			SQLRunner.commit();
			return ;
		} 

		try {
			//2.1 关闭明细行
			BigDecimal qtyClose = dataReader.getBigDecimal("qty_close", BigDecimal.ZERO);
			
			//2.2 关闭积分，数量校验
			BigDecimal rebateCloseAmt = dataReader.getBigDecimal("amt_rebate_close", BigDecimal.ZERO);
			detailEntity.set("amt_rebate_close", rebateCloseAmt);
			
			if (checkQty(detailId, qtyClose) || checkRebateAmt(orderId, rebateCloseAmt)) {
				dataWriter.reportOneError("orderLineClose", "关闭数量/金额超过行数量/金额，不允许关闭");
				SQLRunner.rollback();
				return ;
			}
			
			detailEntity.set("qty_close", qtyClose);
			detailEntity.set("line_state_code", dataReader.getString("line_state_code"));
			detailEntity.set("qty_rebate_close", dataReader.getValue("qty_rebate_close"));
			detailEntity.set("close_reason", dataReader.getValue("close_reason"));
			
			if (!Util.isEmpty(dataReader.getString("todate_close"))) {
				detailEntity.set("todate_close", dataReader.getValue("todate_close"));
			}
			
			dataObject = DataObject.getInstance("so_order_detail");
			dataObject.updateEntity(detailEntity);
				
			//3.记账
			writerCloseBook(detailEntity, "order.line.rebate.qty.close", detailId);
			writerCloseBook(detailEntity, "order.line.rebate.amt.close", detailId);
			
			//4.回写头状态
			BigDecimal orderCloseQty = masterEntity.getBigDecimal("qty_close", BigDecimal.ZERO);
			orderCloseQty = orderCloseQty.add(qtyClose);
			masterEntity.set("qty_close", orderCloseQty);
			dataObject = DataObject.getInstance("so_order");
			dataObject.updateEntity(masterEntity);
			
			orderState = loadOrderState(masterEntity);
		}
		catch (Exception e) {
			dataWriter.reportOneError("orderLineClose", "订单行关闭失败");
			e.printStackTrace();
			SQLRunner.rollback();
		}
		SQLRunner.commit();
		dataWriter.addValue("订单行关闭成功");
	}

	public void orderDetailCancelClose() throws Exception{
		ActionBucket actionBucket = ActionBucket.getInstance();
		ActionMeta action = actionBucket.get("orderDetailCloseCancel");
		WorkStep workStep = new WorkStep(action);
		WorkflowDispatcher dispatcher = WorkflowDispatcher.getInstance();
		dispatcher.execWorkflow(dataReader, dataWriter, workStep, context);
		
		// 更新订单
		DataPackage dataPackage = dataReader.getDataPackage();
		dataPackage.loadOneDataFromPersist();
		Entity master = dataPackage.getMasterEntity();
		
		PackageItem detailItem = dataPackage.getDetailItem();
		DataObject dataObject = detailItem.getDataObject();
		EntitySet detailSet = detailItem.getEntitySet(DataSource.Request);
		EntitySaver saver; Entity detailEntity; 
		String detailId; BigDecimal orderQtyClose = master.getBigDecimal("qty_close", BigDecimal.ZERO), detailQtyClose;
		
		for (Entity detail : detailSet) {
			detailId = detail.getId();
			detailEntity = dataObject.getTableEntity(detailId);
			detailQtyClose = detailEntity.getBigDecimal("qty_close", BigDecimal.ZERO);
			orderQtyClose = orderQtyClose.subtract(detailQtyClose);
			saver = dataObject.createEntitySaver(detailId);
			
			saver.set("qty_close", "");
			saver.set("todate_close", "");
			saver.set("amt_rebate_close", "");
			saver.set("qty_rebate_close", "");
			saver.set("line_state_code", "");
			
			saver.update();
		}
		
		dataObject = dataPackage.getMasterDataObject();
		saver = dataObject.createEntitySaver(dataPackage.getMasterId());
		master.set("qty_close", orderQtyClose);
		saver.set("qty_close", orderQtyClose);
		saver.update();
		
		loadOrderState(master);
	}
	
	public void orderDetailCloseCancel() throws Exception{
		
	}
	
	private boolean checkQty(String orderDetailId, BigDecimal closeQty) throws Exception {
		DataObject dataObject = DataObject.getInstance("so_order_detail");
		Entity detailEntity = dataObject.getTableEntity(orderDetailId);
		BigDecimal lineQty = detailEntity.getBigDecimal("qty", BigDecimal.ZERO);
		
		// 关闭数量超过行数量，则校验不通过
		return closeQty.compareTo(lineQty) > 0;
	}

	private boolean checkRebateAmt(String orderId, BigDecimal rebateCloseAmt) throws Exception {
		DataObject dataObject = DataObject.getInstance("so_order_detail_rebate"); 
		Entity rebateClosedAmtEntity = dataObject.getSummary(" sum(amt) amt_sum ", new Filter("parent_id", orderId));
		BigDecimal orderRebateAmt = rebateClosedAmtEntity.getBigDecimal("amt_sum", BigDecimal.ZERO);
		
		// 关闭数量汇总超过订单总折扣，则校验不通过
		return orderRebateAmt.compareTo(rebateCloseAmt) < 0;
	}

	private void writerCloseBook(Entity detail, String code, String detailId, boolean isBook) throws Exception {
		if(!isBook) {
			return ;
		}
		
		writerCloseBook(detail, code, detailId);
	}

	private void writerCloseBook(Entity detailEntity, String code, String detailId) throws Exception {
		List<BookCommand> bookCommands = BookCommandBucket.get(code);
		
		for(BookCommand bookCommand : bookCommands) {
			//1. 获取数据
			NamedSQL getBookFlow;
			BigDecimal rebateCloseNum;
			Filter filter = new Filter();
			
			if(BookName.RebateAmt.equals(bookCommand.getBookName())){
				getBookFlow = NamedSQL.getInstance("getCloseOrderDetailRebateAmtBookFlow");
				rebateCloseNum = detailEntity.getBigDecimal("amt_rebate_close", BigDecimal.ZERO);
			}
			else {
				getBookFlow = NamedSQL.getInstance("getCloseOrderDetailRebateQtyBookFlow");
				rebateCloseNum = detailEntity.getBigDecimal("qty_rebate_close", BigDecimal.ZERO);
			}
			
			if (BigDecimal.ZERO.equals(rebateCloseNum)) {
				return;
			}
			
			getBookFlow.setParam("document_num", rebateCloseNum);
			getBookFlow.setParam("documentTypeCode" ,bookCommand.getConfigDocTypeSegment());
			getBookFlow.setParam("expireDate", detailEntity.getString("todate_close") );	
			getBookFlow.setParam("batch_mark", bookCommand.getBatchMark());
			
			filter.add("document_detail.id",detailEntity.getString("id"));
			getBookFlow.setFilter(filter);

			
			EntitySet entitySet = SQLRunner.getEntitySet(getBookFlow);
			FlowTable flowTable = bookCommand.getFlowTable();
			flowTable.setEntitySet(entitySet);
			
			//2. 写入流水，明细
			writerRebateFlow(bookCommand);
			writerRebateDetail(bookCommand);
		}
		
	}

	private void writerRebateDetail(BookCommand bookCommand) throws Exception {
		FlowTable flowTable = bookCommand.getFlowTable();
		String fieldType = bookCommand.getBookName().getField();
		DataObject dataObject = DataObject.getInstance(bookCommand.getDetailTableName());
		for (Entity flow : flowTable) {
			Entity entity = dataObject.createTableEntity(false);
			
			String rebateId = bookCommand.getBatchMark();
			entity.set("id", rebateId);	
			entity.set("item_name", flow.getString("rebate_name"));
			entity.set("code", flow.getValue("rebate_code"));
			entity.set("year", flow.getValue("year"));
			entity.set("season", flow.getValue("season"));
			entity.set("valid_to", flow.getValue("valid_to"));
			entity.set("doc_date", flow.getValue("doc_date"));
			entity.set("expire_date", flow.getValue("valid_to"));
			entity.set("valid_from", flow.getValue("valid_from"));
			
			entity.set("bu_id", flow.getString("bu_id"));
			entity.set("bu_name", flow.getString("bu_name"));
			entity.set("company_id", flow.getString("company_id"));
			entity.set("company_name", flow.getString("company_name"));
			
			entity.set("org_id", flow.getString("org_id"));
			entity.set("account_id", flow.getString("account_id"));
			entity.set("account_code", flow.getString("account_code"));
			entity.set("account_name", flow.getString("account_name"));

			entity.set("spec", flow.getString("spec"));
			entity.set("sku_id", flow.getString("sku_id"));
			entity.set("product_id", flow.getString("product_id"));
			entity.set("product_code", flow.getString("product_code"));
			entity.set("product_name", flow.getString("product_name"));
			
			BigDecimal amtUsed = flow.getBigDecimal(fieldType) == null ? BigDecimal.ZERO : flow.getBigDecimal(fieldType);
			entity.set(fieldType + "_book", 0);
			entity.set(fieldType + "_used", amtUsed.negate());
			entity.set(fieldType + "_net", amtUsed);
			entity.set(fieldType + "_freeze", 0);
			entity.set(fieldType + "_available", amtUsed);
			
			entity.set("operate_name", flow.getValue("operate_name"));
			entity.set("batch_mark", flow.getValue("batch_mark"));
			entity.set("create_time", new Date());
			entity.set("update_time", new Date());
			dataObject.insertEntity(entity, true);
			
			updateDocDetailRebateId(flow.getString("document_detail_id"), rebateId, fieldType);
		}
	}

	private void updateDocDetailRebateId(String docDetailId, String rebateId, String type) throws Exception {
		DataObject dataObject = DataObject.getInstance("so_order_detail");
		EntitySaver saver = dataObject.createEntitySaver(docDetailId);
		
		if ("amt".equals(type)) {
			saver.set("close_amt_rebate_id", rebateId);
		}
		else {
			saver.set("close_qty_rebate_id", rebateId);
		}
		
		saver.update();
	}

	private void writerRebateFlow(BookCommand bookCommand) throws Exception {
		QtyCommand qtyCommand = bookCommand.getQtyCommand();
		if (qtyCommand.isDoNothing()) {
			return;
		}
		
		//1. 记录流水账
		DataObject dataObject = DataObject.getInstance(bookCommand.getFlowTableName());
		String batchMark = bookCommand.getBatchMark();
		FlowTable flowTable = bookCommand.getFlowTable();
		
		for (Entity flow : flowTable) {
			String field = bookCommand.getBookName().getField();
			BigDecimal qty = flow.getBigDecimal(field);
			EntitySaver saver = dataObject.createEntitySaver();
			
			saver.set("id", ID.newValue());	
			saver.set("rebate_id", flow.getValue("rebate_id"));
			saver.set("rebate_code", flow.getValue("rebate_code"));
			saver.set("operate_name", flow.getValue("operate_name"));
			saver.set("year", flow.getValue("year"));
			saver.set("season", flow.getValue("season"));
			saver.set("doc_code", flow.getValue("doc_code"));
			saver.set("doc_date", flow.getValue("doc_date"));
			saver.set("expire_date", flow.getValue("valid_to"));
			saver.set("valid_from", flow.getValue("valid_from"));
			saver.set("valid_to", flow.getValue("valid_to"));

			saver.set("bu_id", flow.getValue("bu_id"));
			saver.set("bu_name", flow.getValue("bu_name"));
			saver.set("company_id", flow.getValue("company_id"));
			saver.set("company_name", flow.getValue("company_name"));
            saver.set("org_id", flow.getValue("org_id"));
            saver.set("account_id", flow.getValue("account_id"));
            saver.set("account_code", flow.getValue("account_code"));
            saver.set("account_name", flow.getString("account_name"));

            saver.set("spec", flow.getString("spec"));
            saver.set("sku_id", flow.getString("sku_id"));
            saver.set("product_id", flow.getString("product_id"));
            saver.set("product_code", flow.getString("product_code"));
            saver.set("product_name", flow.getString("product_name"));
			
			boolean negativeConver = bookCommand.isNegativeConvert();
			
			if (qtyCommand.isSetAdd()) {
				BigDecimal qty_add = qty.multiply(qtyCommand.getAddOperator());
				
				if (qty_add.compareTo(BigDecimal.ZERO) < 0 && negativeConver) {
					saver.set("num_used", BigDecimal.ZERO.subtract(qty_add));
				}
				else {
					saver.set("num_return", qty_add);
				}
			}	
			
			if (qtyCommand.isSetDelete()) {
				BigDecimal qty_delete = qty.multiply(qtyCommand.getDeleteOperator());
				
				if (qty_delete.compareTo(BigDecimal.ZERO) < 0 && negativeConver) {
					saver.set("num_return", BigDecimal.ZERO.subtract(qty_delete));
				}
				else {
					saver.set("num_used", qty_delete);
				}
			}
		
			FreezeCondition freezeCondition = bookCommand.getFreezeCondition();
					
			if (qtyCommand.isSetFreeze()) {
				BigDecimal qty_freeze = qty.multiply(qtyCommand.getFreezeOperator());
				
				if (freezeCondition.isCompatible(qty_freeze)) {
					saver.set("num_freeze", qty_freeze);
				}
			}
			
			if (qtyCommand.isSetUnfreeze()) {
				BigDecimal qty_unfreeze = qty.multiply(qtyCommand.getUnfreezeOperator()); 
				
				if (freezeCondition.isCompatible(qty_unfreeze)) {
					saver.set("num_unfreeze", qty_unfreeze);
				}
			}
			saver.set("record_operator", RecordOperator.Insert.name());
			saver.set("batch_mark", batchMark);
			saver.insert();
		}

	}

	private OrderState loadOrderState(Entity order) throws Exception {
		OrderState orderState = OrderState.parse(order.getString("state_code"));
		OrderState refreshState;
		BigDecimal deliveryQty  = order.getBigDecimal("qty_delivery", BigDecimal.ZERO);
		BigDecimal totalQty  = order.getBigDecimal("qty_total", BigDecimal.ZERO);
		BigDecimal returnQty  = order.getBigDecimal("qty_return", BigDecimal.ZERO);
		BigDecimal closeQty  = order.getBigDecimal("qty_close", BigDecimal.ZERO);
		BigDecimal orderQty = totalQty;
		BigDecimal completedQty = deliveryQty.add(closeQty);
		completedQty = completedQty.add(returnQty);
		
		if (BigDecimal.ZERO.equals(deliveryQty)) {
			refreshState = OrderState.Open;
		}
		
		if (completedQty.compareTo(orderQty) >= 0) {
			refreshState = OrderState.Whole;
		}
		else if (BigDecimal.ZERO.compareTo(deliveryQty) < 0) {
			refreshState = OrderState.Partial;
		}
		else {
			logger.info("订单状态【" + orderState.getName() + "】未发生改变");
			return orderState;
		}
		
		DataObject dataObject = DataObject.getInstance("so_order");
		if(!orderState.equals(refreshState)) {
			EntitySaver saver = dataObject.createEntitySaver(order);
			String stateName = refreshState.getName();
			saver.set("state_code",refreshState);
			saver.set("state_name",stateName);
			saver.update();
			logger.info("订单【" + order.getString("code") + "】状态为：" + stateName);
		}
		return refreshState;
	}
	
}