iamberry-watero/watero-wechat-web/src/main/java/com/iamberry/wechat/handles/admin/AdminOrderHandlers.java

package com.iamberry.wechat.handles.admin;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.iamberry.wechat.core.entity.cart.ShopOrderItemDto;
import com.iamberry.wechat.face.cart.CartService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;









//import cn.jpush.api.common.connection.IHttpClient.RequestMethod;
import com.iamberry.app.tool.log.RatFWLogger;
import com.iamberry.wechat.core.entity.OrderUtil;
import com.iamberry.wechat.core.entity.drp.PlaceInfo;
import com.iamberry.wechat.core.entity.member.CashLog;
import com.iamberry.wechat.core.entity.member.Member;
import com.iamberry.wechat.core.entity.mq.MQMessage;
import com.iamberry.wechat.core.entity.order.MessageDto;
import com.iamberry.wechat.core.entity.order.Order;
import com.iamberry.wechat.core.entity.order.OrderActionDto;
import com.iamberry.wechat.core.entity.order.OrderItem;
import com.iamberry.wechat.core.entity.reback.RebackInfo;
import com.iamberry.wechat.core.entity.relationship.DealerRelation;
import com.iamberry.wechat.core.entity.relationship.WdRelation;
import com.iamberry.wechat.face.drp.PlaceInfoService;
import com.iamberry.wechat.face.member.MemberService;
import com.iamberry.wechat.face.order.AdminOrderService;
import com.iamberry.wechat.face.reback.LoadRewardTaskService;
import com.iamberry.wechat.face.reback.RebackServices;
import com.iamberry.wechat.face.relationship.DealerRelationService;
import com.iamberry.wechat.face.relationship.WdRelationService;
import com.iamberry.wechat.handles.mq.MQServiceProxy;
import com.iamberry.wechat.tools.DateTimeUtil;
import com.iamberry.wechat.tools.NameUtils;
import com.iamberry.wechat.tools.ResultInfo;
import com.iamberry.wechat.sendMsg.SendMessageUtil;

@Controller
@RequestMapping("/admin/order")
public class AdminOrderHandlers {
	
	@Autowired
	private AdminOrderService adminOrderService;
	
	@Autowired
	private OrderUtil orderUtil;
	
	@Autowired
	private SendMessageUtil sendMessageUtil;
	
	@Autowired
	private MemberService memberService;
	
	@Autowired
	private WdRelationService wdRelationService;
	
	
	@Autowired
	private DealerRelationService dealerRelationService;
	
	@Autowired
	private PlaceInfoService placeInfoService;
	
	
	
	@Autowired
	private RatFWLogger logger;
	
	@Autowired
	private MQServiceProxy mQservice;
	
	@Autowired
	private RebackServices rebackServices;

	@Autowired
	private CartService cartService;
	
	/**
	 * 后台进入订单列表功能
	 * @param request
	 * @param pageSize
	 * @param pageNO
	 * @return ModelAndView
	 * @throws Exception
	 */
	@RequestMapping("/selectShopOrder")
	public ModelAndView selectShopOrder(HttpServletRequest request,
			@RequestParam(value= "pageSize",defaultValue= "20" ,required=false) Integer pageSize, 
			@RequestParam(value = "pageNO", defaultValue = "1",required=false) Integer pageNO) throws Exception {
		ModelAndView mv = new ModelAndView("admin/order/orderList");
		String orderStatus = request.getParameter("orderStatus");
		if (orderStatus == null || "".equals(orderStatus)) {
			orderStatus = "paySuccess";
		}
		// 订单状态，数字标识
		int status = -1;
		if (!orderStatus.equals("allOrder")) {
			status = orderUtil.getOrderStatusByStr(orderStatus);
		}
		Order order = new Order();
		order.setSalesStatus(status);
		order.getPage().setPageSize(pageSize);
		order.getPage().setPageNumber(pageNO);
		order.getPage().initRecordBegin();
		List<Order> orderList = this.adminOrderService.selectShopOrder(order);
		
		
		// 订单是否按照状态查询的, 用于页面
		if (status == -1) {
			mv.addObject("orderListIsStatus", false);
			for (Order orders : orderList) {
				// 用户昵称编码
				if (orders.getUserNickname() != null && !orders.getUserNickname().isEmpty()) {
					orders.setUserNickname(URLDecoder.decode(orders.getUserNickname(), "UTF-8"));
				}
				// 获取用户的操作权限
				orders.setOperations(orderUtil.orderStatusToOperation(orders.getSalesStatus(), orders.getSalesOrderid()));
				orders.setOrderLinkStatus(orderUtil.orderStatusToString(orders.getSalesStatus())); // 订单状态描述，中文
				
				// 遍历订单, 判断用户角色
				if (orders.getPlaceOpenID() != null && orders.getPlaceOpenID().equals(orders.getSalesOrderid())) {
					// 金牌会员
					orders.setUserResource("金牌会员");
				} else if (orders.getVipRole() != null && orders.getVipRole().equals("52") && orders.getUserResource().equals("3")) {
					// 金牌会员直属下线
					orders.setUserResource("金牌会员直属下线");
				} else {
					// 会员
					String role = "会员";
					switch (Integer.parseInt(orders.getUserResource())) {
						case 47:
							role = "合伙人下线";
							break;
						case 48:
							role = "门店下线";
							break;
						case 49:
							role = "微代理下线";
							break;
						case 51:
							role = "VIP会员下线";
							break;
						case 52:
							role = "金牌会员下线";
							break;
						case 53:
							role = "钻石下线";
							break;
						default:
							break;
					}
					orders.setUserResource(role);
				}
			}
		} else {
			mv.addObject("orderListIsStatus", true);
			for (Order orders : orderList) {
				// 用户昵称编码
				if (orders.getUserNickname() != null && !orders.getUserNickname().isEmpty()) {
					orders.setUserNickname(URLDecoder.decode(orders.getUserNickname(), "UTF-8"));
				}
				// 获取用户的操作权限
				orders.setOperations(orderUtil.orderStatusToOperation(orders.getSalesStatus(), orders.getSalesOrderid()));
				
				// 遍历订单, 判断用户角色
				if (orders.getPlaceOpenID() != null && orders.getPlaceOpenID().equals(orders.getSalesOrderid())) {
					// 金牌会员
					orders.setUserResource("金牌会员");
				} else if (orders.getVipRole() != null && orders.getVipRole().equals("52") && orders.getUserResource().equals("3")) {
					// 金牌会员直属下线
					orders.setUserResource("金牌会员直属下线");
				} else {
					// 会员
					String role = "会员";
					switch (Integer.parseInt(orders.getUserResource())) {
						case 47:
							role = "合伙人下线";
							break;
						case 48:
							role = "门店下线";
							break;
						case 49:
							role = "微代理下线";
							break;
						case 51:
							role = "VIP会员下线";
							break;
						case 52:
							role = "金牌会员下线";
							break;
						case 53:
							role = "钻石下线";
							break;
						default:
							break;
					}
					orders.setUserResource(role);
				}
			}
		}
		mv.addObject("orderList", orderList);
		mv.addObject("pageNO", pageNO);
		mv.addObject("orderStatus", status);// 订单状态
		mv.addObject("url", "/admin/order/selectShopOrder?orderStatus=" + orderStatus + "&pageSize=" + pageSize + "&pageNO=");
		mv.addObject("pageSize", this.adminOrderService.selectShopOrderCount(order));
		mv.addObject("orderStatusStr", orderUtil.orderStatusIntToOrderStatusString(status));// 订单状态描述（用于选中订单头）
		mv.addObject("orderLinkStatus", orderUtil.orderStatusToString(status));// 订单状态描述，中文（显示给用户看）
		mv.addObject("statusUrl", "/admin/order/selectShopOrder?bid=&sid=");
		return mv;
	}
	
	/**
	 * 订单详细信息
	 * @param request
	 * @param orderId
	 * @return ModelAndView
	 * @throws Exception
	 */
	@ResponseBody
	@RequestMapping("/getShopOrderByOrderId/{orderId}")
	public ModelAndView getShopOrderByOrderId(HttpServletRequest request,
			@PathVariable("orderId") String orderId) throws Exception{
		ModelAndView mv = new ModelAndView("admin/order/order");
		if (null != orderId && !"".equals(orderId)) {
			Order order = this.adminOrderService.getShopOrderByOrderId(orderId);
			List<OrderItem> orderItemList = this.adminOrderService.getShopOrderItemByOrderId(orderId);
				// 用户昵称编码
				if (order.getUserNickname() != null && !order.getUserNickname().isEmpty()) {
					order.setUserNickname(URLDecoder.decode(order.getUserNickname(), "UTF-8"));
				}
				// 获取用户的操作权限
				order.setOperations(orderUtil.orderStatusToOperation(order.getSalesStatus(), order.getSalesOrderid()));
				order.setOrderLinkStatus(orderUtil.orderStatusToString(order.getSalesStatus())); // 订单状态描述，中文
				if (order.getSalesStatus() == 2) {
					// 给百胜推送信息
					try {
						MQMessage message = new MQMessage();
						message.setServiceToMessage(orderId);
						message.setServiceOtherMessage("efast.trade.detail.get");
						message.setServiceIsSend(2);			// 没有推送的信息
						message.setServiceStatus(1); 			// 推送成功
						message.setServiceType(1); 				// 添加订单信息
						message.setServiceHandlerObjectName("efastOrderServiceImpl");
						message.setServiceHandlerMethodName("selectEfastSendOrderInfo");
						mQservice.insertMQMessage(message);
					} catch (Exception e) {
						// TODO: handle exception
					}
				} else if (order.getSalesStatus() == 8) {
					// 给百胜推送信息
					try {
						MQMessage message = new MQMessage();
						message.setServiceToMessage(orderId);
						message.setServiceOtherMessage("efast.order.return.info.fetch");
						message.setServiceIsSend(2);			// 没有推送的信息
						message.setServiceStatus(1); 			// 推送成功
						message.setServiceType(1); 				// 添加订单信息
						message.setServiceHandlerObjectName("efastOrderServiceImpl");
						message.setServiceHandlerMethodName("selectEfastReturnOrderInfo");
						mQservice.insertMQMessage(message);
					} catch (Exception e) {
						// TODO: handle exception
					}
				}
			mv.addObject("order",order);
			mv.addObject("orderItemList", orderItemList);
		}
		return mv;
	}
	
	@RequestMapping(value="/selectShopOrderByOrderId")
	public ModelAndView selectShopOrderByOrderId(HttpServletRequest request, 
			@RequestParam(value= "pageSize",defaultValue= "20" ,required=false) Integer pageSize, 
			@RequestParam(value = "pageNO", defaultValue = "1",required=false) Integer pageNO,
			OrderActionDto actionDto) throws Exception {
		ModelAndView mv = new ModelAndView("admin/order/orderList");
		Order order = new Order();
		String orderStatus = request.getParameter("orderStatus");
		
		//url需要进行拼接，拼接的内容是页面上的时间条件
		StringBuffer url = new StringBuffer("/admin/order/selectShopOrderByOrderId?orderStatus=" + actionDto.getOrderStatus());
		
		// 判断是否输入数据
				if (!(actionDto.getText() == null || actionDto.getText().isEmpty())) {
					url.append("&text=" + actionDto.getText());
				}
		//分页并带条件查询接收参数
		String beginTime = request.getParameter("beginDate");
		String endTime = request.getParameter("endDate");
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		
		
		String salesAddressTel = request.getParameter("salesAddressTel");
		String salesAddressName = request.getParameter("salesAddressName");
		String salesAddressInfo = request.getParameter("salesAddressInfo");
		if (salesAddressTel != null && !"".equals(salesAddressTel)) {
			order.setSalesAddressTel(salesAddressTel);
			mv.addObject("salesAddressTel", salesAddressTel);
			url.append("&salesAddressTel=" + salesAddressTel);
		}
		if (salesAddressName != null && !"".equals(salesAddressName)) {
			order.setSalesAddressName(salesAddressName);
			mv.addObject("salesAddressName", salesAddressName);
			url.append("&salesAddressName=" + salesAddressName);
		}
		if (salesAddressInfo != null && !"".equals(salesAddressInfo)) {
			order.setSalesAddressInfo(salesAddressInfo);
			mv.addObject("salesAddressInfo", salesAddressInfo);
			url.append("&salesAddressInfo=" + salesAddressInfo);
		}
		
		if (null != beginTime && !"".equals(beginTime)) {
			if (!request.getMethod().equalsIgnoreCase("post")) {
				actionDto.setBeginDate(format.parse(new String(beginTime.getBytes("ISO-8859-1"), "UTF-8")));
			} else {
				actionDto.setBeginDate(format.parse(beginTime));
			}
		}
		if (null != endTime && !"".equals(endTime)) {
			if (!request.getMethod().equalsIgnoreCase("post")) {
				actionDto.setEndDate(format.parse(new String(endTime.getBytes("ISO-8859-1"), "UTF-8")));
			} else {
				actionDto.setEndDate(format.parse(endTime));
			}
		}
		if (null != actionDto.getBeginDate()) {
			url.append( "&beginDate=" + format.format(actionDto.getBeginDate()));
			mv.addObject("beginDate", format.format(actionDto.getBeginDate()));
		}
		if (null != actionDto.getEndDate()) {
			url.append("&endDate=" + format.format(actionDto.getEndDate()));
			mv.addObject("endDate", format.format(actionDto.getEndDate()));
		}
		url.append("&pageSize=" + pageSize + "&pageNO=");
		
		if (orderStatus == null || "".equals(orderStatus)) {
			orderStatus = "paySuccess";
		}
		// 订单状态，数字标识
		int status = -1;
		if (!orderStatus.equals("allOrder")) {
			status = orderUtil.getOrderStatusByStr(orderStatus);
		}
		order.setSalesStatus(status);
		order.setSalesOrderid(actionDto.getText());
		order.setBeginDate(actionDto.getBeginDate());
		order.setEndDate(actionDto.getEndDate());
		order.getPage().setPageSize(pageSize);
		order.getPage().setPageNumber(pageNO);
		order.getPage().initRecordBegin();
		List<Order> orderList = this.adminOrderService.selectShopOrderByOrderId(order);
		// 订单是否按照状态查询的, 用于页面
			if (status == -1) {
				mv.addObject("orderListIsStatus", false);
				for (Order orders : orderList) {
					// 用户昵称编码
					if (orders.getUserNickname() != null && !orders.getUserNickname().isEmpty()) {
						orders.setUserNickname(URLDecoder.decode(orders.getUserNickname(), "UTF-8"));
					}
					// 获取用户的操作权限
					orders.setOperations(orderUtil.orderStatusToOperation(orders.getSalesStatus(), orders.getSalesOrderid()));
					orders.setOrderLinkStatus(orderUtil.orderStatusToString(orders.getSalesStatus())); // 订单状态描述，中文
				}
			} else {
				mv.addObject("orderListIsStatus", true);
				for (Order orders : orderList) {
					// 用户昵称编码
					if (orders.getUserNickname() != null && !orders.getUserNickname().isEmpty()) {
						orders.setUserNickname(URLDecoder.decode(orders.getUserNickname(), "UTF-8"));
					}
					// 获取用户的操作权限
					orders.setOperations(orderUtil.orderStatusToOperation(orders.getSalesStatus(), orders.getSalesOrderid()));
				}
			}
		// 时间区间的处理
		String beginDateTime = "";
		SimpleDateFormat simple = null;
		if (actionDto.getBeginDate() != null) {
			simple = new SimpleDateFormat("yyyy-MM-dd");
			beginDateTime = simple.format(actionDto.getBeginDate());
		}
		String endDate = "";
		if (actionDto.getEndDate() != null) {
			if (simple == null) {
				simple = new SimpleDateFormat("yyyy-MM-dd");
			}
			endDate = simple.format(actionDto.getEndDate());
		}
		mv.addObject("orderList", orderList);
		mv.addObject("pageNO", pageNO);
		mv.addObject("orderStatus", status);// 订单状态
		mv.addObject("url", url.toString());
		mv.addObject("pageSize", this.adminOrderService.selectShopOrderCount(order));
		mv.addObject("orderStatusStr", orderUtil.orderStatusIntToOrderStatusString(status));// 订单状态描述（用于选中订单头）
		mv.addObject("orderLinkStatus", orderUtil.orderStatusToString(status));// 订单状态描述，中文（显示给用户看）
		mv.addObject("statusUrl", "/admin/order/selectShopOrderByOrderId?bid=&sid=");
		mv.addObject("beginDate", beginDateTime);
		mv.addObject("endDate", endDate);
		mv.addObject("selectInput", actionDto.getText());
		return mv;
	}
	
	/**
	 * 操作订单
	 * @return
	 * @throws Exception 
	 */
	@RequestMapping("/{action}/{orderId}")
	public synchronized ModelAndView actionOrder(
			@PathVariable("action") String action,
			@PathVariable("orderId") String orderId,
			OrderActionDto actionDto
			) throws Exception {
		ModelAndView mv = new ModelAndView("admin/msg/msg");
		Order order = new Order();
		order.setSalesOrderid(orderId);
		// 订单状态，数字标识
		order.setSalesPostFirm(actionDto.getPostFirm());
		order.setSalesPostNum(actionDto.getPostNum());
		// 判断当前的订单，是否支持希望进行的操作
		Order currentOrder = adminOrderService.selectOrderStatusByOrderId(orderId);
		Integer orderStatus = currentOrder.getSalesStatus();
		order.setOldStatus(orderStatus);
		if (!orderUtil.orderStatusIntToOrderStatusString(orderStatus).equals(actionDto.getOrderStatus())) {
			mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
			return mv;
		}
		switch (orderStatus) {
			case 0: // 取消的订单，不支持任何修改订单状态的操作
				
				mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，取消的订单不能操作!"));
				return mv;
			case 1: // 待支付（管理员存在操作权限：取消订单，如果取消订单，订单状态修改为0）
				
				if (!orderUtil.getOrderActin()[0].equals(action)) {// 判断当前请求操作是否相符, 否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				if (!orderUtil.orderStatusIntToOrderStatusString(0).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				order.setSalesStatus(orderUtil.getOrderStatusByStr(actionDto.getToOrderStatus()));
				// 执行修改操作
				if (adminOrderService.updateOrderStatusByOrderId(order)) {
					mv.addObject("msgObj", new MessageDto(true, "取消订单成功", "恭喜您！订单：" + orderId + "取消成功，本订单将不能操作!"));
					return mv;
				} else {
					mv.addObject("msgObj", new MessageDto(false, "对不起，取消订单失败", "对不起，取消订单失败，请稍后重试！"));
					return mv;
				}
			case 2: // 已支付、待发货（管理员的操作为：确认发货）
				
				if (!orderUtil.getOrderActin()[2].equals(action)) {// 判断当前请求操作是否相符, 否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				if (!orderUtil.orderStatusIntToOrderStatusString(5).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				// 执行修改操作
				order.setSalesStatus(orderUtil.getOrderStatusByStr(actionDto.getToOrderStatus()));
				if (adminOrderService.deliverOrderByOrderId(order)) {
					mv.addObject("msgObj", new MessageDto(true, "操作成功", "请到百胜系统确认该订单是否已经确认，如果没有确认，该订单仍是待发货状态!"));
					logger.info("准备为用户推送模版信息!");
					// 给百胜推送信息
					try {
						MQMessage message = new MQMessage();
						message.setServiceToMessage(orderId);
						message.setServiceOtherMessage(actionDto.getPostFirm() + "-" + actionDto.getPostNum());
						message.setServiceIsSend(2);			// 没有推送的信息
						message.setServiceStatus(1); 			// 推送成功
						message.setServiceType(1); 				// 添加订单信息
						message.setServiceHandlerObjectName("efastOrderServiceImpl");
						message.setServiceHandlerMethodName("sendOrderInfoToEfast");
						mQservice.insertMQMessage(message);
					} catch (Exception e) {
						// TODO: handle exception
					}
					//给用户发送消息-已发货的通知
					
					
					//消息内容
					String data = ResultInfo.ORDERPACKAGETEMP;
					data = data.replaceFirst("firstValueOrder", ResultInfo.SHIPMENTMESSAGE)
						.replaceFirst("orderIdValueOrder",  orderId)
						.replaceFirst("orderValuePackageId",SendMessageUtil.hashmap.get(actionDto.getPostFirm())+":"+actionDto.getPostNum())
						.replaceFirst("orderRemarkValue", ResultInfo.INTOSHOP);
					sendMessageUtil.sendTemplateMessageToOpenid(data, currentOrder.getSalesOpenid(), ResultInfo.PAGE_SHIPMENT+orderId, 2);
					
					return mv;
				} else {
					mv.addObject("msgObj", new MessageDto(false, "对不起，取消订单失败", "对不起，取消订单失败，请稍后重试！"));
					return mv;
				}
			case 3: // 退款申请中（管理员可以操作：确认退款）
				
				// 只有两种操作 : 确认退款、驳回退款
				if (orderUtil.getOrderActin()[4].equals(action)) {
					// 驳回退款
					
					if (!orderUtil.orderStatusIntToOrderStatusString(2).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
						mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
						return mv;
					}
					order.setSalesStatus(2);
					if (adminOrderService.updateOrderStatusByOrderId(order)) {// 驳回退款
						mv.addObject("msgObj", new MessageDto(true, "驳回退款成功!", "驳回退款成功，订单进入待发货状态!"));
						return mv;
					} else {
						mv.addObject("msgObj", new MessageDto(false, "对不起，驳回退款订单失败", "对不起，对不起，驳回退款订单失败，请稍后重试！"));
						return mv;
					}
				} else if (orderUtil.getOrderActin()[5].equals(action)) {
					// 同意退款 , 需要回滚积分
					
					if (!orderUtil.orderStatusIntToOrderStatusString(4).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
						mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
						return mv;
					}
					order.setSalesStatus(4);
					if (adminOrderService.updateOrderStatusByOrderId(order)) {
						//将返利表中待入账改为已入账
						RebackInfo rabackInfo = new RebackInfo();
						rabackInfo.setOrderId(order.getSalesOrderid());
						rabackInfo.setStatus(3);
						//根据orderId查询订单所有信息
						Order orderInfo = adminOrderService.getShopOrderByOrderId(orderId);
						Member member = new Member();
						//判断该订单是否用过余额支付，如果有，则退款后该支付的余额会退回到用户余额中
						if (orderInfo != null && orderInfo.getBalancePayAmount() != null) {
							member.setUserOpenid(orderInfo.getSalesOpenid());
							member.setUserIncome(orderInfo.getBalancePayAmount());
							adminOrderService.updateUserByUserId(member);
							//将数据存入日志中
							CashLog cashLog = new CashLog();
							cashLog.setCashLogsOpenid(orderInfo.getSalesOpenid());
							cashLog.setCashLogsOrderid(orderId);
							cashLog.setCashLogsNum(orderInfo.getBalancePayAmount());
							cashLog.setCashLogsType(1);
							cashLog.setCashLogsIntroduction("退款");
							cashLog.setCashLogsResType(5);
							cashLog.setCashLogsCreateDate(new Date());
							adminOrderService.addCashLog(cashLog);
						}
						rebackServices.updateStatus(rabackInfo);
						mv.addObject("msgObj", new MessageDto(true, "订单退款成功", "恭喜您!订单退款成功，订单将封存!"));
						updateRebate(order,3);
						return mv;
					} else {
						mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
						return mv;
					}
				} else {
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
			case 4: // 已退款（管理员通过申请退款，此时订单任何人不能操作）
				
				mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，已退款的订单不能操作!"));
				return mv;
			case 5: // 已发货（管理员不具有权限）
				
				mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，已发货的订单不能操作!"));
				return mv;
			case 6: // 申请退货中（只有管理员能操作 : 确认退货）
				
				if (!orderUtil.getOrderActin()[6].equals(action) && !orderUtil.getOrderActin()[10].equals(action)) {// 判断当前请求操作是否相符, 否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				if (!orderUtil.orderStatusIntToOrderStatusString(7).equals(actionDto.getToOrderStatus())
						&& !orderUtil.orderStatusIntToOrderStatusString(5).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				// 执行修改操作
				order.setSalesStatus(orderUtil.getOrderStatusByStr(actionDto.getToOrderStatus()));
				if (adminOrderService.updateOrderStatusByOrderId(order)) {
					if(orderUtil.orderStatusIntToOrderStatusString(7).equals(actionDto.getToOrderStatus())){
						mv.addObject("msgObj", new MessageDto(true, "订单申请退货成功", "恭喜您！同意订单：" + orderId + "退货，等待收到货物后确认退货!"));
					}else{
						mv.addObject("msgObj", new MessageDto(true, "成功驳回订单退货", "订单：" + orderId + "退货被驳回,状态返回已发货!"));
					}
					return mv;
				} else {
					mv.addObject("msgObj", new MessageDto(false, "对不起，取消订单失败", "对不起，取消订单失败，请稍后重试！"));
					return mv;
				}
			case 7: // 退货中（管理员具有操作能力:确认退货）
				
				if (!orderUtil.getOrderActin()[7].equals(action)) {// 判断当前请求操作是否相符, 否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				if (!orderUtil.orderStatusIntToOrderStatusString(8).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				// 执行修改操作
				order.setSalesStatus(8);
				if (adminOrderService.updateOrderStatusByOrderId(order)) {
					//将返利表中待入账改为已入账
					RebackInfo rabackInfo = new RebackInfo();
					rabackInfo.setOrderId(order.getSalesOrderid());
					rabackInfo.setStatus(3);
					rebackServices.updateStatus(rabackInfo);
					
					//根据orderId查询订单所有信息
					Order orderInfo = adminOrderService.getShopOrderByOrderId(orderId);
					Member memberInfo = new Member();
					//判断该订单是否用过余额支付，如果有，则退款后该支付的余额会退回到用户余额中
					if (orderInfo != null && orderInfo.getBalancePayAmount() != null) {
						memberInfo.setUserOpenid(orderInfo.getSalesOpenid());
						memberInfo.setUserIncome(orderInfo.getBalancePayAmount());
						adminOrderService.updateUserByUserId(memberInfo);
						//将数据存入日志中
						CashLog cashLog = new CashLog();
						cashLog.setCashLogsOpenid(orderInfo.getSalesOpenid());
						cashLog.setCashLogsOrderid(orderId);
						cashLog.setCashLogsNum(orderInfo.getBalancePayAmount());
						cashLog.setCashLogsType(1);
						cashLog.setCashLogsIntroduction("退货");
						cashLog.setCashLogsResType(5);
						cashLog.setCashLogsCreateDate(new Date());
						adminOrderService.addCashLog(cashLog);
					}
					
					mv.addObject("msgObj", new MessageDto(true, "确认订单退货成功", "恭喜您！同意订单：" + orderId + "退货，订单关闭!"));
					updateRebate(order,3);
					try {
						MQMessage message = new MQMessage();
						message.setServiceToMessage(orderId);
						message.setServiceOtherMessage(currentOrder.getSalesPostFirm() + "-" + currentOrder.getSalesPostNum());
						message.setServiceIsSend(2);			// 没有推送的信息
						message.setServiceStatus(1); 			// 推送成功
						message.setServiceType(1); 				// 添加订单信息
						message.setServiceHandlerObjectName("efastOrderServiceImpl");
						message.setServiceHandlerMethodName("returnOrderInfoToEfast");
						mQservice.insertMQMessage(message);
					} catch (Exception e) {
						// TODO: handle exception
					}
					//推送金额变动消息
					Member member = memberService.getMemberByUserOpenId(currentOrder.getSalesOpenid());
					if(member != null || member.getUserResType() != null) {
						String toopenid = "";
						switch(member.getUserResType().intValue()){//用户来源
							case 2:		//用户来源	微代理
								WdRelation wdrelation = wdRelationService.getWdRelationByOpenid(currentOrder.getSalesOpenid());
								Member fatherMember = memberService.getMemberByUserId(wdrelation.getWdFirst());	//微代理父节点信息
								if(fatherMember != null && StringUtils.isNotEmpty(fatherMember.getUserOpenid())){
									toopenid = fatherMember.getUserOpenid();
								}
								break;
							case 3:		//用户来源	线下
								DealerRelation dealerrelation= dealerRelationService.getDealerRelationById(member.getUserDealers());
								int Dealerid = 0;
								if(dealerrelation!=null){
									if(dealerrelation.getDealerThird()!=null){ //第三极
										Dealerid = dealerrelation.getDealerThird();
									}else if(dealerrelation.getDealerSecond()!=null){ //第二级
										Dealerid = dealerrelation.getDealerSecond();
									}else if(dealerrelation.getDealerFifth()!=null){ //第一级
										Dealerid = dealerrelation.getDealerFifth();}
								}
								PlaceInfo fatherPlace = placeInfoService.getPlaceInfoById(Dealerid);//分销父节点信息
								if(fatherPlace!=null){
									toopenid = fatherPlace.getOpenid();
								}
								break;
						}
						//发送消息
						String temp = ResultInfo.INCOMEREMINDTEMP;
						temp = temp.replaceFirst("firstValueIamberry", ResultInfo.NEXTUSERTUIHUOMESSAGE)
								.replaceFirst("accountValueIamberry",URLDecoder.decode( member.getUserNickname(), "UTF-8"))
								.replaceFirst("timeValueIamberry", DateTimeUtil.format(new Date(),NameUtils.getConfig("DATE_TIME_FORMAT")))
								.replaceFirst("typeValueIamberry", "用户退货")
								.replaceFirst("remarkValueIamberry", ResultInfo.INTOSHOP);
						sendMessageUtil.sendTemplateMessageToOpenid(temp, toopenid, ResultInfo.TUIHUI_SHIPMENT,3);	
					}
					
					return mv;
				} else {
					mv.addObject("msgObj", new MessageDto(false, "对不起，取消订单失败", "对不起，取消订单失败，请稍后重试！"));
					return mv;
				}
			case 8: // 订单退货，订单关闭（管理员收到货后，确认退货，订单状态修改为此，订单不对外提供操作能力）
				
				mv.addObject("msgObj", new MessageDto(false, "对不起，操作订单失败", "对不起，订单退货，订单关闭，本订单不能操作！"));
				return mv;
			case 9: // 换货中（管理员对申请换货的订单，确认换货时，订单状态为此，此时只有管理员具有操作权限，只能确认换货，录入物流信息，并重新计算订单关闭的时间，待入账积分的时间要修改）
				
				if (!orderUtil.getOrderActin()[9].equals(action)) {// 判断当前请求操作是否相符, 否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				if (!orderUtil.orderStatusIntToOrderStatusString(5).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				// 执行修改操作
				if ("2".equals(currentOrder.getSalesProxyReward().toString())) {
					order.setSalesStatus(orderUtil.getOrderStatusByStr("inFinish"));
				} else {
					order.setSalesStatus(orderUtil.getOrderStatusByStr(actionDto.getToOrderStatus()));
				}
				if (adminOrderService.deliverOrderByOrderId(order)) {
					mv.addObject("msgObj", new MessageDto(true, "订单发货成功", "恭喜您！订单：" + orderId + "订单发货成功!"));
					try {
						MQMessage message = new MQMessage();
						message.setServiceToMessage(orderId);
						message.setServiceOtherMessage("efast.trade.new.add");
						message.setServiceIsSend(2);			// 没有推送的信息
						message.setServiceStatus(1); 			// 推送成功
						message.setServiceType(1); 				// 添加订单信息
						message.setServiceHandlerObjectName("efastOrderServiceImpl");
						message.setServiceHandlerMethodName("exchangeOrderInfoToEfast");
						mQservice.insertMQMessage(message);
					} catch (Exception e) {
						System.out.println("===========pay 201  插入返利到百胜失败==============");		
					}
					return mv;
				} else {
					mv.addObject("msgObj", new MessageDto(false, "对不起，订单发货失败", "对不起，订单发货失败，请稍后重试！"));
					return mv;
				}
			case 10: // 换货完成，当用户对换货中的订单，点击确认换货时，并录入物流信息，此订单进入已发货状态
				
				break;
			case 11: // 在订单为已发货时，用户具有的权限，用户申请换货
				
				if (!orderUtil.getOrderActin()[8].equals(action) && !orderUtil.getOrderActin()[11].equals(action)) {// 判断当前请求操作是否相符, 否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				if (!orderUtil.orderStatusIntToOrderStatusString(9).equals(actionDto.getToOrderStatus())
						&& !orderUtil.orderStatusIntToOrderStatusString(5).equals(actionDto.getToOrderStatus())) {// 判断请求修改的订单状态是否相符，否则提示不成功
					mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误，请按照系统流程操作！"));
					return mv;
				}
				// 执行修改操作
				if (!orderUtil.orderStatusIntToOrderStatusString(9).equals(actionDto.getToOrderStatus())) {
					if ("2".equals(currentOrder.getSalesProxyReward().toString())) {
						order.setSalesStatus(orderUtil.getOrderStatusByStr("inFinish"));
					} else {
						order.setSalesStatus(orderUtil.getOrderStatusByStr(actionDto.getToOrderStatus()));
					}
				} else {
					order.setSalesStatus(orderUtil.getOrderStatusByStr(actionDto.getToOrderStatus()));
				}
				if (adminOrderService.updateOrderStatusByOrderId(order)) {
					if(orderUtil.orderStatusIntToOrderStatusString(9).equals(actionDto.getToOrderStatus())){
						mv.addObject("msgObj", new MessageDto(true, "同意换货成功", "恭喜您！同意订单：" + orderId + "换货，请收货后录入物流信息并同意换货!"));
					}else{
						mv.addObject("msgObj", new MessageDto(true, "驳回换货成功", "您已驳回订单：" + orderId + "换货，订单状态改为已发货!"));
					}
					return mv;
				} else {
					mv.addObject("msgObj", new MessageDto(false, "对不起，取消订单失败", "对不起，取消订单失败，请稍后重试！"));
					return mv;
				}
			default: // 报错
				
				mv.addObject("msgObj", new MessageDto(false, "对不起，操作有误", "对不起，您刚才的操作流程有误!"));
				return mv;
		}
		
		return mv;
	}
	
	/**
	 * 修改返利表的返现状态
	 * @param order
	 * @param status
	 */
	public void updateRebate(Order order, int status) {
		RebackInfo rabackInfo = new RebackInfo();
		rabackInfo.setOrderId(order.getSalesOrderid());
		rabackInfo.setStatus(status);
		LoadRewardTaskService.updateStatus(rabackInfo);
	}
	
	/**
	 * 订单备注
	 * @param actionDTO
	 * @throws IOException
	 */
	@RequestMapping(value="/remark/{id}",produces = {"application/json;charset=UTF-8"})
	@ResponseBody
	public String orderRemark(OrderActionDto actionDto, @PathVariable("id") String orderId, HttpServletResponse response) throws IOException {
		String remark = "";
		// 订单备注
		if (actionDto.getRemarkColor() == null) {
			actionDto.setRemarkColor(1);
		}
		if (actionDto.getRemark() == null || actionDto.getRemark().isEmpty()) {
			return "{\"status\":\"false\",\"info\":\"备注信息不能为空!\"}";
		}
		if (actionDto.getRemark().length() > 100) {
			return "{'\"status\":\"false\",\"info\":\"备注信息不能超过100个字符!\"}";
		}
		//查询该订单的状态
		Order order = adminOrderService.selectOrderStatusByOrderId(orderId);
		if (null == order) {
			return "{\"status\":true,\"info\":\"该订单不存在!\"}";
		}
		if (!"8".equals(order.getSalesStatus().toString())) {
			remark = actionDto.getRemark();
		}
		// update到数据库
		if (adminOrderService.updateOrderAdminRemarkByOrderId(remark, orderId, actionDto.getRemarkColor())) {
			return "{\"status\":true,\"info\":\"备注成功!\"}";
		} else {
			return "{\"status\":\"false\",\"info\":\"备注失败，请稍后重试!\"}";
		}
	}


	//默认分配拼单的信息
	private static String hxgOrderid = "1225094505P11863I";
	private static String hxgOpenid = "o3G6nw_3cxE7CINzCT1or2f6dxL4";

	/**
	 * 系统拼单
	 * @param
	 * @throws IOException
	 */
	@RequestMapping(value="/spell",produces = {"application/json;charset=UTF-8"})
	@ResponseBody
	public String spell(HttpServletResponse response,HttpServletRequest request) throws IOException {
		String orderId = request.getParameter("orderId");
		//查询该订单的状态
		Order order = adminOrderService.selectOrderStatusByOrderId(orderId);
		if (null == order) {
			return "{\"status\":true,\"info\":\"该订单不存在!\"}";
		}
		if (!"15".equals(order.getSalesStatus().toString())) {
			return "{\"status\":true,\"info\":\"该订单已完成拼单!\"}";
		}
		/**
		 * 修改拼单信息并推送
		 */
		if(order.getSalesStatus() != null && order.getSalesStatus() == 15){
			//邀请人订单修改
			Order or1 = new Order();
			or1.setSalesOrderid(orderId);
			or1.setSalesStatus(2);
			or1.setSalesSpellOrderId(hxgOrderid);//默认何秀刚的已完成订单
			cartService.updateOrderSpellOrderId(or1);//修改状态为已支付，待发货，关联拼单订单id
			//邀请人信息state
			List<ShopOrderItemDto> orderItems1 = cartService.selectShopOrderItem(orderId);
			//邀请人信息end
			if(order.getSalesOpenid() != null){
				Member	memberOne = memberService.getMemberByUserOpenId(order.getSalesOpenid());
				String name = "我";
				if(memberOne != null && !memberOne.getUserNickname().equals("")){
					try {
						name = URLDecoder.decode(memberOne.getUserNickname(),"UTF-8");
					} catch (UnsupportedEncodingException e) {
						e.printStackTrace();
					}
				}
				String names  = name +","+"微信好友";
				//推送微信模板消息
                logger.info("微信账户支付推送拼单成功消息-------------------------------------------------5");
				try {
					sendMessageUtil.spellPush(
							"恭喜您与微信好友拼单成功，点击逛逛更多好货吧。",
							orderItems1.get(0).getItemProductName(),
							names,
							"点击查看拼单详情>>",
							order.getSalesOpenid(),
                            ResultInfo.ORDER_GUOQI+"?salesStatus=2");
				}catch (Exception e){
					logger.info("推送拼单成功消息失败，失败openId："+order.getSalesOpenid());
					e.printStackTrace();
				}
				// 给rst推送订单
				try {
					MQMessage message = new MQMessage();
					message.setServiceToMessage(orderId);
					message.setServiceOtherMessage("efast.trade.new.add");
					message.setServiceIsSend(2);			// 没有推送的信息
					message.setServiceStatus(1); 			// 推送成功
					message.setServiceType(1); 				// 添加订单信息
					message.setServiceHandlerObjectName("efastOrderServiceImpl");
					message.setServiceHandlerMethodName("addOrderInfoToEfast");
					mQservice.insertMQMessage(message);
				} catch (Exception e) {
					e.printStackTrace();
					return "{\"status\":false,\"info\":\"拼单失败，请稍后重试!\"}";
				}
			}
		}else{
			return "{\"status\":false,\"info\":\"拼单失败，请检查订单状态!\"}";
		}
		return "{\"status\":true,\"info\":\"拼单成功!\"}";

	}


	/**
	 * 查询订单是否拼团成功
	 * @param request
	 * @param orderId
	 * @return ModelAndView
	 * @throws Exception
	 */
/*	@ResponseBody
	@RequestMapping("/getOrderByOrderId/{orderId}")
	public String getOrderByOrderId(HttpServletRequest request,
											  @PathVariable("orderId") String orderId) throws Exception{
		Order order = new Order();
		if (null != orderId && !"".equals(orderId)) {
			order = this.adminOrderService.getShopOrderByOrderId(orderId);

		}
		return order.getSalesSpellOrderId();
	}*/
}