合并

CODE/smart-community/app-api/src/main/java/com/community/huiju/common/perproties/PayNotifyPerproties.java

 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.stereotype.Component;
 
+import java.math.BigDecimal;
+
 /**
  * 支付回调地址配置
  * @author weiximei
 public class PayNotifyPerproties {
 
     /**
-     * 微信回调
+     * 微信回调 物业缴费
      */
     private String wxBillNotify;
 
     /**
-     * 支付宝回调
+     * 支付宝回调 物业缴费
      */
     private String aliBillNotify;
 
+    /**
+     * 微信回调 车缴费
+     */
+    private String wxCarNotify;
+
+    /**
+     * 支付宝回调 车缴费
+     */
+    private String aliCarNotify;
+
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/config/BillQuartz.java

 package com.community.huiju.config;
 
+import com.community.huiju.dao.TaUserLicenseOrderMapper;
 import com.community.huiju.dao.TpBillInvoiceMapper;
 import com.community.huiju.dao.TpBillOrderMapper;
+import com.community.huiju.model.TaUserLicenseOrder;
 import com.community.huiju.model.TpBillInvoice;
 import com.community.huiju.model.TpBillOrder;
 import lombok.extern.slf4j.Slf4j;
     @Autowired
     private TpBillInvoiceMapper tpBillInvoiceMapper;
 
+    @Autowired
+    private TaUserLicenseOrderMapper taUserLicenseOrderMapper;
+
     @Scheduled(cron = "0 0/10 * * * ?")
     public void billInvoice() {
         log.info("定时任务，扫描订单，超过 10 分未付款则，关闭订单！");
+        // 物业缴费
         List<TpBillOrder> billOrderList = tpBillOrderMapper.selectCloseOrder();
         if (!billOrderList.isEmpty()) {
             // 把缴费单变为未交费
             });
 
         }
+
+        // 车缴费订单
+        List<TaUserLicenseOrder> userLicenseOrders = taUserLicenseOrderMapper.selectCloseOrder();
+        if (!userLicenseOrders.isEmpty()) {
+            userLicenseOrders.forEach(e-> {
+                e.setOrderStatus("3");
+                taUserLicenseOrderMapper.updateByPrimaryKeySelective(e);
+            });
+        }
+
+
     }
 
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/controller/AliPayController.java

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.cloud.context.config.annotation.RefreshScope;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 	private String ALIPAY_PUBLIC_KEY;
 	
 	@ApiOperation(value = "统一下单", notes = "统一下单")
-	@ApiImplicitParams({ @ApiImplicitParam(paramType = "path", dataType = "Integer", name = "billInvoiceId", value = "账单Id"),
+	@ApiImplicitParams({
+			@ApiImplicitParam(paramType = "path", dataType = "String", name = "outTradeNo", value = "订单号"),
+			@ApiImplicitParam(paramType = "form", dataType = "String", name = "type", value = "订单类型：type: 类型(car 车缴费, bill 物业缴费)"),
 			@ApiImplicitParam(paramType = "header",dataType = "String",name = "X-Auth-Token",value = "Token") })
 	@RequestMapping(value = "/aliPayOrder/{outTradeNo}",method = RequestMethod.GET)
-	public ResponseBean wxUnifiedOrder(@PathVariable("outTradeNo") String outTradeNo, HttpSession session){
+	public ResponseBean wxUnifiedOrder(@PathVariable("outTradeNo") String outTradeNo, @RequestParam("type") String type, HttpSession session){
 		ResponseBean responseBean = new ResponseBean();
 		UserElement userElement = (UserElement) session.getAttribute(Constant.APP_USER_SESSION);
 		String resp = "";
 		try {
-			resp = aliPayService.AliPayOrder(outTradeNo,userElement);
+			resp = aliPayService.AliPayOrder(outTradeNo, type,userElement);
 		} catch (Exception e) {
 			e.printStackTrace();
 			responseBean.addError(e.getMessage());
 		return responseBean;
 	}
 	
-	@ApiOperation(value = "支付宝手机订单支付完成后回调", notes = "支付宝手机订单支付完成后回调")
-	@RequestMapping(value = "/aliPayNotify",method = RequestMethod.POST)
-	public void aliPayNotify(HttpServletRequest request, HttpServletResponse response){
+	@ApiOperation(value = "支付宝手机订单支付完成后回调 物业缴费", notes = "支付宝手机订单支付完成后回调")
+	@RequestMapping(value = "/aliPayBillNotify",method = RequestMethod.POST)
+	public void aliPayBillNotify(HttpServletRequest request, HttpServletResponse response){
+		wxNotify(request, Constant.PAY_TYPE_BILL);
+	}
+
+	@ApiOperation(value = "支付宝手机订单支付完成后回调 车缴费", notes = "支付宝手机订单支付完成后回调 车缴费")
+	@RequestMapping(value = "/aliPayCarNotify",method = RequestMethod.POST)
+	public void aliPayCarNotify(HttpServletRequest request, HttpServletResponse response){
+		wxNotify(request, Constant.PAY_TYPE_CAR);
+	}
+
+	/**
+	 * 支付回调
+	 * @param request
+	 * @param type
+	 */
+	private void wxNotify(HttpServletRequest request, String type) {
 		System.out.println("alipay result  start =======");
 		Map<String,String> params = new HashMap<String,String>();
 		Map requestParams = request.getParameterMap();
 			boolean flag = AlipaySignature.rsaCheckV1(params, ALIPAY_PUBLIC_KEY, CHARSET_UTF8,"RSA2");
 			if (flag){
 				params.put("pay_type","2");
-				wxPayService.wxNotify(params);
+				if (Constant.PAY_TYPE_BILL.equals(type)) {
+					wxPayService.wxBillNotify(params);
+				} else if (Constant.PAY_TYPE_CAR.equals(type)){
+					wxPayService.wxCarNotify(params);
+				}
+
 			}
 		} catch (AlipayApiException e) {
 			e.printStackTrace();
 			e.printStackTrace();
 		}
 	}
+
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/controller/WxPayController.java

 		return responseBean;
 	}
 	
-	@ApiOperation(value = "手机订单支付完成后回调", notes = "手机订单支付完成后回调")
-	@RequestMapping(value = "/wxNotify",method = RequestMethod.POST)
-	public String wxNotify(HttpServletRequest request, HttpServletResponse response){
+	@ApiOperation(value = "手机订单支付完成后回调 物业缴费", notes = "手机订单支付完成后回调 物业缴费")
+	@RequestMapping(value = "/wxBillNotify",method = RequestMethod.POST)
+	public String wxBillNotify(HttpServletRequest request, HttpServletResponse response){
+		return wxNotify(request, Constant.PAY_TYPE_BILL);
+	}
+
+
+	@ApiOperation(value = "手机订单支付完成后回调 车缴费", notes = "手机订单支付完成后回调 车缴费")
+	@RequestMapping(value = "/wxCarNotify",method = RequestMethod.POST)
+	public String wxCarNotify(HttpServletRequest request, HttpServletResponse response){
+
+		return wxNotify(request, Constant.PAY_TYPE_CAR);
+	}
+
+	/**
+	 * 微信支付回调
+	 * @param request
+	 * @param type
+	 * @return
+	 */
+	private String wxNotify(HttpServletRequest request, String type) {
 		String failResult = "<xml>" + "<return_code><![CDATA[FAIL]]></return_code>" + "<return_msg><![CDATA[失败]]></return_msg>" + "</xml> ";
 		String successResult = "<xml>" + "<return_code><![CDATA[SUCCESS]]></return_code>" + "<return_msg><![CDATA[OK]]></return_msg>" + "</xml> ";
 		InputStream inStream;
 		try {
-			
+
 			inStream = request.getInputStream();
 			ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
 			byte[] buffer = new byte[1024];
 			while ((len = inStream.read(buffer)) != -1) {
 				outSteam.write(buffer, 0, len);
 			}
-			
+
 			// 获取微信调用我们notify_url的返回信息
 			String result = new String(outSteam.toByteArray(), "utf-8");
 			WXPayUtil.getLogger().info("wxnotify:微信支付----result----=" + result);
-			
+
 			// 关闭流
 			outSteam.close();
 			inStream.close();
-			
+
 			// xml转换为map
 			Map<String, String> resultMap = WXPayUtil.xmlToMap(result);
 			if (WXPayConstants.SUCCESS.equalsIgnoreCase(resultMap.get("result_code"))) {
 				//处理业务逻辑 修改订单状态等
 				resultMap.put("pay_type","0");
-				String state = wxPayService.wxNotify(resultMap);
+				String state = "";
+				if (Constant.PAY_TYPE_CAR.equals(type)) {
+					state = wxPayService.wxCarNotify(resultMap);
+				} else if (Constant.PAY_TYPE_BILL.equals(type)) {
+					state = wxPayService.wxBillNotify(resultMap);
+				}
+
 				if (state.equals("success")){
 					log.info("微信支付成功。。");
 					return successResult;
 			}else{
 				return failResult;
 			}
-			
+
 		} catch (Exception e) {
 			log.error("手机支付回调通知失败",e);
 			return failResult;
-			
+
 		}
+
 		return failResult;
 	}
+
 	
 	@ApiOperation(value = "订单查询", notes = "订单查询")
 	@ApiImplicitParams({
 	
 	@ApiOperation(value = "准备开始支付", notes = "准备开始支付")
 	@ApiImplicitParams({
-			@ApiImplicitParam(paramType = "body", dataType = "Integer", name = "billInvoiceIdList", value = "账单Id集合"),
+			@ApiImplicitParam(paramType = "body", dataType = "String", name = "parameter", value = "idArray:账单Id集合, type: 类型(car 车缴费, bill 物业缴费), extensionMonth: 延期月份，也就是延期几个月！只有在 车缴费的时候才有效"),
 			@ApiImplicitParam(paramType = "header",dataType = "String",name = "X-Auth-Token",value = "Token")
 	})
 	@RequestMapping(value = "/wxStartPay",method = RequestMethod.POST)
-	public ResponseBean wxStartPay(@RequestBody String billInvoiceIdList, HttpSession session){
+	public ResponseBean wxStartPay(@RequestBody String parameter, HttpSession session){
 		ResponseBean responseBean = new ResponseBean();
 		try {
 			UserElement userElement = (UserElement) session.getAttribute(Constant.APP_USER_SESSION);
-			 Integer[] integers = JSONObject.parseArray(billInvoiceIdList).toArray(new Integer[]{});
+			JSONObject jsonObject = JSONObject.parseObject(parameter);
+			Integer[] integers = jsonObject.getJSONArray("idArray").toArray(new Integer[]{});
+			String type = jsonObject.getString("type");
+			Integer extensionMonth = jsonObject.getInteger("extensionMonth");
 
-			String outTradeNo = wxPayService.wxStartPay( Arrays.asList(integers), userElement);
+			String outTradeNo = wxPayService.wxStartPay(Arrays.asList(integers), type, extensionMonth,userElement);
 			Map<String,Object> resultMap = Maps.newHashMap();
 			resultMap.put("outTradeNo", outTradeNo);
 			responseBean.addSuccess(resultMap);
 	
 	@ApiOperation(value = "取消支付", notes = "取消支付")
 	@ApiImplicitParams({
-			@ApiImplicitParam(paramType = "path", dataType = "Integer", name = "outTradeNo", value = "订单号"),
+			@ApiImplicitParam(paramType = "path", dataType = "String", name = "outTradeNo", value = "订单号"),
+			@ApiImplicitParam(paramType = "form", dataType = "String", name = "outTradeNo", value = "type: 类型(car 车缴费, bill 物业缴费)"),
 			@ApiImplicitParam(paramType = "header",dataType = "String",name = "X-Auth-Token",value = "Token")
 	})
 	@RequestMapping(value = "/wxCancelPay/{outTradeNo}",method = RequestMethod.POST)
-	public ResponseBean wxCancelPay(@PathVariable("outTradeNo") String outTradeNo, HttpSession session){
+	public ResponseBean wxCancelPay(@PathVariable("outTradeNo") String outTradeNo, @RequestParam("type") String type,HttpSession session){
 		ResponseBean responseBean = new ResponseBean();
 		try {
 			UserElement userElement = (UserElement) session.getAttribute(Constant.APP_USER_SESSION);
-			wxPayService.wxCancelPay(outTradeNo,userElement);
+			wxPayService.wxCancelPay(outTradeNo, type,userElement);
 		} catch (Exception e) {
 			e.printStackTrace();
 			responseBean.addError(e.getMessage());

CODE/smart-community/app-api/src/main/java/com/community/huiju/dao/TaUserLicenseOrderMapper.java

 package com.community.huiju.dao;
 
 import com.community.huiju.model.TaUserLicenseOrder;
+import com.community.huiju.model.TpBillOrder;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.ResultMap;
     @ResultMap("BaseResultMap")
     @Select("select * from ta_user_license_order where community_id = #{communityId} and ta_user_id = #{userId} and order_status = 1")
     List<TaUserLicenseOrder> selectRecords(@Param("communityId") Integer communityId, @Param("userId") Integer userId);
+
+    /**
+     * 根据订单号查询
+     * @param orderNo
+     * @return
+     */
+    @ResultMap("BaseResultMap")
+    @Select("select * from ta_user_license_order where order_number=#{orderNo}")
+    List<TaUserLicenseOrder> selectByOrderNumber(String orderNo);
+
+    /**
+     * 可关闭的订单
+     * @return
+     */
+    @ResultMap("BaseResultMap")
+    @Select("SELECT t.* from ta_user_license_order t where TIMESTAMPDIFF(MINUTE,create_date,now()) >= 10 and t.order_status in (0,2)")
+    List<TaUserLicenseOrder> selectCloseOrder();
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/model/TpBillInvoice.java

     /**
      * 转换后金额，用于支付
      */
-    private String sumPayPrice;
+    private Double sumPayPrice;
 
     public Integer getId() {
         return id;
         this.payType = payType;
     }
 
-    public String getSumPayPrice() {
+    public Double getSumPayPrice() {
         return sumPayPrice;
     }
 
-    public void setSumPayPrice(String sumPayPrice) {
+    public void setSumPayPrice(Double sumPayPrice) {
         this.sumPayPrice = sumPayPrice;
     }
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/model/TpBillOrder.java

     /**
      * 订单总额
      */
-    private String sumPrice;
+    private Double sumPrice;
 
     /**
      * 缴费单集合
         this.billList = billList;
     }
 
-    public String getSumPrice() {
+    public Double getSumPrice() {
         return sumPrice;
     }
 
-    public void setSumPrice(String sumPrice) {
+    public void setSumPrice(Double sumPrice) {
         this.sumPrice = sumPrice;
     }
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/service/AliPayServiceI.java

 	 * 微信支付统一下单
 	 * @return
 	 * @param outTradeNo
+	 * @param type  类型(car 车缴费, bill 物业缴费)
 	 * @param userElement
 	 */
-	String AliPayOrder(String outTradeNo, UserElement userElement) throws Exception;
+	String AliPayOrder(String outTradeNo, String type, UserElement userElement) throws Exception;
 	
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/service/ITaUserLicenseService.java

      */
     ResponseBean associatedLicense(UserElement userElement, String carNo);
 
+    /**
+     * 用户查询车牌
+     * @param carNo
+     * @return
+     */
+    ResponseBean getLicense(UserElement userElement, String carNo);
+
     /**
      * 获取用户所有车牌
      * @param userElement

CODE/smart-community/app-api/src/main/java/com/community/huiju/service/WxPayServiceI.java

 	Map<String, String> wxUnifiedOrder(String outTradeNo, String type, UserElement userElement) throws Exception;
 	
 	/**
-	 * 支付成功的回调
+	 * 支付成功的回调 物业缴费
 	 * @return
 	 * @param resultMap
 	 */
-	String wxNotify(Map<String, String> resultMap) throws Exception;
+	String wxBillNotify(Map<String, String> resultMap) throws Exception;
 	
 	/**
 	 * 订单查询
 	
 	/**
 	 * 准备支付
-	 * @param billInvoiceIdArray
+	 * @param idArray 账单的id
 	 * @param userElement
+	 * @param type 订单类型  car 车缴费 , bill 物业缴费
+	 * @param extensionMonth 延期月份，也就是延期几个月！
+	 *                        	只有在 车缴费的时候才有效
 	 * @throws Exception
 	 */
-	String wxStartPay(List<Integer> billInvoiceIdArray, UserElement userElement) throws Exception;
+	String wxStartPay(List<Integer> idArray, String type,  Integer extensionMonth, UserElement userElement) throws Exception;
 	
 	/**
 	 * 取消支付
 	 * @param outTradeNo 订单号
+	 * @param type  订单类型  car 车缴费 , bill 物业缴费
 	 * @param userElement
 	 */
-	void wxCancelPay(String outTradeNo, UserElement userElement) throws Exception;
+	void wxCancelPay(String outTradeNo, String type, UserElement userElement) throws Exception;
+
+	/**
+	 * 支付成功的回调 车缴费
+	 * @param resultMap
+	 * @return
+	 */
+	String wxCarNotify(Map<String, String> resultMap);
+
+	/**
+	 * 根据订单类型获取 金额 和 回调地址
+	 * @param type
+	 * @param orderNo
+	 * @return
+	 * @throws Exception
+	 */
+	Map<String,Object> getOrderPriceAndNotifyUrl(String type, String orderNo) throws Exception;
 }

CODE/smart-community/app-api/src/main/java/com/community/huiju/service/impl/AliPayServiceImpl.java

 import com.alipay.api.domain.AlipayTradeAppPayModel;
 import com.alipay.api.request.AlipayTradeAppPayRequest;
 import com.alipay.api.response.AlipayTradeAppPayResponse;
+import com.community.commom.constant.Constant;
 import com.community.commom.session.UserElement;
 import com.community.huiju.common.perproties.PayNotifyPerproties;
 import com.community.huiju.common.wxpay.HfWxConfig;
 import com.community.huiju.model.TpBillInvoice;
 import com.community.huiju.model.TpBillOrder;
 import com.community.huiju.service.AliPayServiceI;
+import com.community.huiju.service.WxPayServiceI;
 import org.apache.commons.collections.CollectionUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.math.BigDecimal;
 import java.util.List;
+import java.util.Map;
 
 import static com.alipay.api.AlipayConstants.CHARSET_UTF8;
 
 	private String ALIPAY_PUBLIC_KEY;
 
 	@Autowired
-	private PayNotifyPerproties payNotifyPerproties;
+	private WxPayServiceI wxPayServiceI;
+
 
 	/**
 	 * 支付宝统一下单
 	 */
 	@Override
 	@Transactional(rollbackFor = Exception.class)
-	public String AliPayOrder(String outTradeNo, UserElement userElement) throws Exception {
-		Integer userId = userElement.getId();
-
-		//获取支付金额
-		List<TpBillOrder> billOrderList = tpBillOrderMapper.selectByOrderBumber(outTradeNo);
-		if (CollectionUtils.isEmpty(billOrderList)){
-			throw new Exception("订单不存在");
-		}
-
-		// 计算金额
-		Integer payPrice = billOrderList.stream().mapToInt(e -> tpBillInvoiceMapper.selectByPrimaryKey(e.getTpBillInvoiceId()).getPayPrice()).sum();
+	public String AliPayOrder(String outTradeNo, String type, UserElement userElement) throws Exception {
 
+		String typeName = Constant.PAY_TYPE_BILL.equals(type) ? "物业缴费" : Constant.PAY_TYPE_CAR.equals(type) ? "车缴费" : "缴费";
+		Map<String, Object> orderPriceAndNotifyUrl = wxPayServiceI.getOrderPriceAndNotifyUrl(type, outTradeNo);
 		
 		//下单
 		AlipayClient alipayClient = new DefaultAlipayClient("https://openapi.alipay.com/gateway.do", ALI_APP_ID, APP_PRIVATE_KEY, "json", CHARSET_UTF8, ALIPAY_PUBLIC_KEY, "RSA2");
 		AlipayTradeAppPayRequest request = new AlipayTradeAppPayRequest();
 		//SDK已经封装掉了公共参数，这里只需要传入业务参数。以下方法为sdk的model入参方式(model和biz_content同时存在的情况下取biz_content)。
 		AlipayTradeAppPayModel model = new AlipayTradeAppPayModel();
-		model.setBody("缴费");
-		model.setSubject("缴费");
+		model.setBody(typeName);
+		model.setSubject(typeName);
 		model.setOutTradeNo(outTradeNo);
 		model.setTimeoutExpress("30m");
-		model.setTotalAmount(BigDecimal.valueOf(Long.valueOf(payPrice)).divide(new BigDecimal(100)).toString());
+		model.setTotalAmount(BigDecimal.valueOf(Long.valueOf(String.valueOf(orderPriceAndNotifyUrl.get("payPrice")))).divide(new BigDecimal(100)).toString());
 		model.setProductCode("QUICK_MSECURITY_PAY");
 		request.setBizModel(model);
-		request.setNotifyUrl(payNotifyPerproties.getAliBillNotify());
+		request.setNotifyUrl(String.valueOf(orderPriceAndNotifyUrl.get("notifyUrl")));
 		try {
 			//这里和普通的接口调用不同，使用的是sdkExecute
 			AlipayTradeAppPayResponse response = alipayClient.sdkExecute(request);

CODE/smart-community/app-api/src/main/java/com/community/huiju/service/impl/BillServiceImpl.java

 		List<Map<String,Object>> billsList = tpBillInvoiceMapper.getBillsList(userElement.getCommunityId(), userElement.getRoomNoId(), payType);
 		billsList.forEach(e-> {
 			String payPrice = String.valueOf(e.get("payPrice"));
-			String payPriceDouble = BigDecimal.valueOf(Long.valueOf(payPrice)).divide(new BigDecimal(100)).toString();
+			Double payPriceDouble = Double.valueOf(payPrice) / 100;
 			e.put("payPrice", payPriceDouble);
 		});
 		Map<String,Object> result = Maps.newHashMap();
 	public Map<String, Object> getBillInvoiceDetail(Integer communityId,Integer billInvoiceId) {
 		Map<String, Object> billInvoiceDetail = tpBillInvoiceMapper.getBillInvoiceDetail(communityId, billInvoiceId);
 		String payPrice = String.valueOf(billInvoiceDetail.get("payPrice"));
-		String payPriceDouble = BigDecimal.valueOf(Long.valueOf(payPrice)).divide(new BigDecimal(100)).toString();
+		Double payPriceDouble = Double.valueOf(payPrice) / 100;
 		billInvoiceDetail.put("payPrice", payPriceDouble);
 		return billInvoiceDetail;
 	}
 
 			// 缴费组
 			List<TpBillInvoice> tpBillInvoices = orderList.stream().map(billOrder -> tpBillInvoiceMapper.selectByIdBillInvoiceInfo(billOrder.getTpBillInvoiceId())).collect(Collectors.toList());
-			tpBillInvoices.forEach( billInvoice -> billInvoice.setSumPayPrice(BigDecimal.valueOf(Long.valueOf(billInvoice.getPayPrice())).divide(new BigDecimal(100)).toString()));
+			tpBillInvoices.forEach( billInvoice -> billInvoice.setSumPayPrice(Double.valueOf(billInvoice.getPayPrice() + "") / 100));
 
 			// 所有缴费组的总额
-			String billCountPrice = BigDecimal.valueOf(Long.valueOf(tpBillInvoices.stream().map(billCount -> billCount.getPayPrice()).count())).divide(new BigDecimal(100)).toString();
+			Double billCountPrice = Double.valueOf(tpBillInvoices.stream().map(billCount -> billCount.getPayPrice()).count() + "") / 100;
 
 
 			e.setBillList(tpBillInvoices);
 		}
 		// 每个缴费单数据
 		List<TpBillInvoice> tpBillInvoices = billOrderList.stream().map(e -> tpBillInvoiceMapper.selectByIdBillInvoiceInfo(e.getTpBillInvoiceId())).collect(Collectors.toList());
-		tpBillInvoices.forEach(e -> e.setSumPayPrice(BigDecimal.valueOf(Long.valueOf(e.getPayPrice())).divide(new BigDecimal(100)).toString()));
+		tpBillInvoices.forEach(e -> e.setSumPayPrice(Double.valueOf(e.getPayPrice() + "") / 100));
 
 		// 这个订单总额
-		String billCountPrice = BigDecimal.valueOf(Long.valueOf(tpBillInvoices.stream().map(e -> e.getPayPrice()).count())).divide(new BigDecimal(100)).toString();
+		Double billCountPrice = Double.valueOf(tpBillInvoices.stream().map(e -> e.getPayPrice()).count() + "") / 100;
 
 		// 因为订单号是多条，取第一条即可
 		TpBillOrder tpBillOrder = billOrderList.get(0);

CODE/smart-community/app-api/src/main/java/com/community/huiju/service/impl/TaUserLicenseServiceImpl.java

 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.math.BigDecimal;
 import java.text.ParseException;
     private IFuShiService iFuShiService;
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public ResponseBean associatedLicense(UserElement userElement, String carNo) {
         ResponseBean responseBean = new ResponseBean();
 
         if (null == taUserLicense.getId()) {
             rows = taUserLicenseMapper.insertSelective(taUserLicense);
         } else {
+            taUserLicense.setUpdateUser(userElement.getId());
+            taUserLicense.setUpdateDate(new Date());
             rows = taUserLicenseMapper.updateByPrimaryKeySelective(taUserLicense);
         }
 
 
         if (rows > 0) {
+            taUserLicense.setUnitPrice(String.valueOf(Double.valueOf(taUserLicense.getUnitPrice()) / 100));
             responseBean.addSuccess(taUserLicense);
             return responseBean;
         }
         return responseBean;
     }
 
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public ResponseBean getLicense(UserElement userElement, String carNo) {
+        ResponseBean responseBean = new ResponseBean();
+        TaUserLicense taUserLicense = taUserLicenseMapper.selectByUserIdAndCommunityIdAndLicensePlate(userElement.getCommunityId(), userElement.getId(), carNo);
+        if (null != taUserLicense) {
+            taUserLicense = getTaUserLicense(carNo, taUserLicense);
+            taUserLicense.setUpdateUser(userElement.getId());
+            taUserLicense.setUpdateDate(new Date());
+            taUserLicenseMapper.updateByPrimaryKeySelective(taUserLicense);
+        }
+
+        responseBean.addSuccess(taUserLicense);
+        return responseBean;
+    }
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public ResponseBean getAllUserLicense(UserElement userElement) {
         ResponseBean responseBean = new ResponseBean();
         List<TaUserLicense> taUserLicenses = taUserLicenseMapper.selectAllByCommunityIdAndUserId(userElement.getCommunityId(), userElement.getId());
 
         taUserLicenses = taUserLicenses.stream().map(e-> {
             TaUserLicense taUserLicense = getTaUserLicense(e.getLicensePlate(), e);
+            taUserLicense.setUpdateUser(userElement.getId());
+            taUserLicense.setUpdateDate(new Date());
             taUserLicenseMapper.updateByPrimaryKeySelective(taUserLicense);
+            taUserLicense.setUnitPrice(String.valueOf(Double.valueOf(taUserLicense.getUnitPrice()) / 100));
             return taUserLicense;
         }).collect(Collectors.toList());
 
 
         // 获取到的车牌信息
         Map<String,Object> map = (Map<String,Object>)resultCar;
+        Integer dataType = (Integer) map.get("DataType");
+        if (dataType.intValue() != 1) {
+            throw new WisdomException("该车牌不是月租车！");
+        }
+
         Map<String,Object> jsonParam = (Map<String, Object>) map.get("JsonParam");
 
         taUserLicense.setLicensePlate(carNo);
-        taUserLicense.setUnitPrice(BigDecimal.valueOf(Long.valueOf(String.valueOf(jsonParam.get("Cost")))).multiply(new BigDecimal(100)).toString());
+        String price = String.valueOf(Double.valueOf(((BigDecimal) jsonParam.get("Cost")).toString()) * 100);
+        taUserLicense.setUnitPrice(price.substring(0, price.lastIndexOf(".")));
         taUserLicense.setCreateDate(new Date());
         taUserLicense.setParkingLot(String.valueOf(jsonParam.get("ParkingName")));
 
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public ResponseBean deleteUserLicense(UserElement userElement, Integer licenseId) {
         ResponseBean responseBean = new ResponseBean();
 

CODE/smart-community/app-api/src/main/java/com/community/huiju/service/impl/WxPayServiceImpl.java

 package com.community.huiju.service.impl;
 
+import com.community.commom.constant.Constant;
+import com.community.commom.mode.ResponseBean;
 import com.community.commom.session.UserElement;
 import com.community.huiju.common.perproties.PayNotifyPerproties;
 import com.community.huiju.common.wxpay.HfWxConfig;
 import com.community.huiju.dao.*;
 import com.community.huiju.exception.WisdomException;
 import com.community.huiju.model.*;
+import com.community.huiju.service.IFuShiService;
+import com.community.huiju.service.ITaUserLicenseService;
 import com.community.huiju.service.WxPayServiceI;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.math.BigDecimal;
 import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 	@Autowired
 	private PayNotifyPerproties payNotifyPerproties;
 
+	@Autowired
+	private TaUserLicenseOrderMapper taUserLicenseOrderMapper;
+
+	@Autowired
+	private IFuShiService iFuShiService;
+
+	@Autowired
+	private TaUserLicenseMapper taUserLicenseMapper;
+
+	@Autowired
+	private ITaUserLicenseService iTaUserLicenseService;
+
+
 	/**
 	 * 微信支付统一下单
 	 *
 
 		Map<String, Object> orderPriceAndNotifyUrl = getOrderPriceAndNotifyUrl(type, orderNo);
 
+		String typeName = Constant.PAY_TYPE_BILL.equals(type) ? "物业缴费" : Constant.PAY_TYPE_CAR.equals(type) ? "车缴费" : "缴费";
+
 		//下单
 		Map<String, String> data = new HashMap<String, String>();
-		data.put("body", "缴费");
+		data.put("body", typeName);
 		//商品号唯一
 		data.put("out_trade_no", orderNo);
 		data.put("device_info", "");
 		secondSignData.put("package", "Sign=WXPay");
 		secondSignData.put("sign", WXPayUtil.generateSignature(secondSignData, config.getKey(), WXPayConstants.SignType.MD5));
 
-		log.info("订单: {}， 状态变更为正在支付", orderNo);
+		log.info("订单: {}，订单类型: {}, 状态变更为正在支付", orderNo, type);
 
 		// 更改订单状态 为正在支付
-		List<TpBillOrder> billOrders = tpBillOrderMapper.selectByOrderBumber(orderNo);
-		billOrders.forEach(e-> {
-			e.setOrderStatus("3");
-			tpBillOrderMapper.updateByPrimaryKeySelective(e);
-		});
-
+		updateOrderStatus(orderNo, type, "2");
 		return secondSignData;
 	}
 
 	 * @return
 	 * @throws Exception
 	 */
-	private Map<String,Object> getOrderPriceAndNotifyUrl(String type, String orderNo) throws Exception {
+	@Override
+	public Map<String,Object> getOrderPriceAndNotifyUrl(String type, String orderNo) throws Exception {
 		Map<String,Object> orderMap = Maps.newHashMap();
 
 		// 物业缴费
-		if ("bill".equals(type)) {
+		if (Constant.PAY_TYPE_BILL.equals(type)) {
 			//获取支付金额
 			List<TpBillOrder> billOrderList = tpBillOrderMapper.selectByOrderBumber(orderNo);
 			if (CollectionUtils.isEmpty(billOrderList)){
 				}
 			});
 			// 计算金额
-			Integer payPrice = billOrderList.stream().mapToInt(e -> tpBillInvoiceMapper.selectByPrimaryKey(e.getTpBillInvoiceId()).getPayPrice()).sum();
-
+			Long payPrice = billOrderList.stream().mapToLong(e -> tpBillInvoiceMapper.selectByPrimaryKey(e.getTpBillInvoiceId()).getPayPrice()).sum();
 			orderMap.put("orderNo", orderNo);
 			orderMap.put("payPrice", String.valueOf(payPrice));
 			orderMap.put("notifyUrl", payNotifyPerproties.getWxBillNotify());
 
-		} else if ("car".equals(type)) {
+		} else if (Constant.PAY_TYPE_CAR.equals(type)) { // 车缴费
+			List<TaUserLicenseOrder> userLicenseOrders = taUserLicenseOrderMapper.selectByOrderNumber(orderNo);
+			if (CollectionUtils.isEmpty(userLicenseOrders)) {
+				throw new Exception("订单不存在");
+			}
+			// 检测订单是否 已关闭
+			userLicenseOrders.forEach(e-> {
+				if ("3".equals(e.getOrderStatus())) {
+					throw new WisdomException("无法支付已关闭的订单!");
+				}
+			});
 
+			// 总额
+			Long payPrice = userLicenseOrders.stream().map(e -> Long.parseLong(e.getExtensionPrice())).count();
+			orderMap.put("orderNo", orderNo);
+			orderMap.put("payPrice", String.valueOf(payPrice));
+			orderMap.put("notifyUrl", payNotifyPerproties.getWxCarNotify());
 		}
 
 		return orderMap;
 	}
 
 
+
+
 	/**
 	 * 支付成功的回调
 	 *
 	 */
 	@Override
 	@Transactional(rollbackFor = Exception.class)
-	public String wxNotify(Map<String, String> resultMap) throws Exception {
+	public String wxBillNotify(Map<String, String> resultMap) throws Exception {
 		String outTradeNo = resultMap.get("out_trade_no");
 		List<TpBillOrder> billOrderList = tpBillOrderMapper.selectByOrderBumber(outTradeNo);
 		if (CollectionUtils.isEmpty(billOrderList)){
 //			tpMessageMapper.updateByPrimaryKeySelective(tpMessage);
 		}
 
-		log.info("订单: {}， 状态变更为支付成功", outTradeNo);
+		log.info("订单: {}，订单类型: {}, 状态变更为支付成功", outTradeNo, Constant.PAY_TYPE_BILL);
 
 		// 更改订单状态 为支付成功
-		List<TpBillOrder> billOrders = tpBillOrderMapper.selectByOrderBumber(outTradeNo);
-		billOrders.forEach(e-> {
-			e.setOrderStatus("1");
-			tpBillOrderMapper.updateByPrimaryKeySelective(e);
-		});
+		updateOrderStatus(outTradeNo, Constant.PAY_TYPE_BILL, "1");
 
 		return "success";
 	}
 	
 	@Override
 	@Transactional(rollbackFor = Exception.class)
-	public String wxStartPay(List<Integer> billInvoiceIdArray, UserElement userElement) throws Exception {
+	public String wxStartPay(List<Integer> idArray, String type, Integer extensionMonth, UserElement userElement) throws Exception {
+		if (StringUtils.isBlank(type)) {
+			throw new WisdomException("type 不能为空！");
+		}
 
-		// 如果是家属/租客, 应该用业主的用户id
+		// 缴费的用户
 		TaUser taUser = taUserMapper.selectByPrimaryKey(userElement.getId());
 
 		Random random = new Random();
 		String orderNo = String.valueOf(System.currentTimeMillis()) + random.nextInt();
 
-		//获取支付金额
-		for (Integer billInvoiceId : billInvoiceIdArray) {
-			TpBillInvoice tpBillInvoice = tpBillInvoiceMapper.selectByPrimaryKey(billInvoiceId);
-			if (null == tpBillInvoice){
-				throw new Exception("订单不存在");
-			}else if (!tpBillInvoice.getBillStatus().equals("0")){
-				throw new Exception("正在支付的订单");
+		// 创建订单
+		createOrder(idArray, type, taUser, userElement, orderNo, extensionMonth, null);
+
+		return orderNo;
+	}
+
+	/**
+	 * 创建订单
+	 * @param idArray
+	 * @param type
+	 * @param taUser
+	 * @param userElement
+	 * @param orderNo
+	 * @param extensionMonth 延期月份，也就是延期几个月！
+	 *                       	只有在 车缴费的时候才有效
+	 * @param paymentType 缴费方式 1是支付宝 2是微信支付
+	 * @throws Exception
+	 */
+	private void createOrder(List<Integer> idArray, String type, TaUser taUser, UserElement userElement, String orderNo, Integer extensionMonth, String paymentType) throws Exception {
+		// 物业缴费
+		if (Constant.PAY_TYPE_BILL.equals(type)) {
+			//获取支付金额
+			for (Integer billInvoiceId : idArray) {
+				TpBillInvoice tpBillInvoice = tpBillInvoiceMapper.selectByPrimaryKey(billInvoiceId);
+				if (null == tpBillInvoice){
+					throw new Exception("订单不存在");
+				}else if (!tpBillInvoice.getBillStatus().equals("0")){
+					throw new Exception("正在支付的订单");
+				}
+
+				TpBillOrder tpBillOrder = new TpBillOrder();
+				tpBillOrder.setCommunityId(userElement.getCommunityId());
+				tpBillOrder.setTpBillId(tpBillInvoice.getBillId());
+				tpBillOrder.setTpBillInvoiceId(tpBillInvoice.getId());
+				tpBillOrder.setCreateDate(new Date());
+				tpBillOrder.setCreateUser(userElement.getId());
+				tpBillOrder.setUpdateDate(new Date());
+				tpBillOrder.setUpdateUser(userElement.getId());
+				tpBillOrder.setOrderBumber(orderNo);
+				tpBillOrder.setPayPhone(taUser.getLoginName());
+				tpBillOrder.setOrderStatus("0");
+
+				tpBillOrderMapper.insertSelective(tpBillOrder);
+
 			}
+			// 修改缴费人, 修改为正在缴费
+			updateBillInvoiceBillStatus(idArray, taUser.getUserName(), "2");
 
-			TpBillOrder tpBillOrder = new TpBillOrder();
-			tpBillOrder.setCommunityId(userElement.getCommunityId());
-			tpBillOrder.setTpBillId(tpBillInvoice.getBillId());
-			tpBillOrder.setTpBillInvoiceId(tpBillInvoice.getId());
-			tpBillOrder.setCreateDate(new Date());
-			tpBillOrder.setCreateUser(userElement.getId());
-			tpBillOrder.setUpdateDate(new Date());
-			tpBillOrder.setUpdateUser(userElement.getId());
-			tpBillOrder.setOrderBumber(orderNo);
-			tpBillOrder.setPayPhone(taUser.getLoginName());
-			tpBillOrder.setOrderStatus("0");
+			// 车缴费
+		} else if (Constant.PAY_TYPE_CAR.equals(type)) {
+			if (null == extensionMonth && extensionMonth > 0) {
+				throw new Exception("延期月份不能为空，并且要大于0!");
+			}
 
-			tpBillOrderMapper.insertSelective(tpBillOrder);
+			for (Integer clicenseId : idArray) {
+				// 根据车牌id，查询车牌
+				TaUserLicense taUserLicense = taUserLicenseMapper.selectByPrimaryKey(clicenseId);
+				// 获取车牌最新信息
+				ResponseBean responseLicense = iTaUserLicenseService.getLicense(userElement, taUserLicense.getLicensePlate());
+				Object licenseData = responseLicense.getData();
+				if (null != licenseData && licenseData instanceof TaUserLicense) {
+					taUserLicense = (TaUserLicense) licenseData;
+				}
 
-		}
+				TaUserLicenseOrder taUserLicenseOrder = new TaUserLicenseOrder();
+				taUserLicenseOrder.setCommunityId(userElement.getCommunityId());
+				taUserLicenseOrder.setTaUserId(userElement.getId());
+				taUserLicenseOrder.setOrderNumber(orderNo);
+				taUserLicenseOrder.setOrderStatus("0");
+				taUserLicenseOrder.setCreateDate(new Date());
+				taUserLicenseOrder.setCreateUser(userElement.getId());
+				taUserLicenseOrder.setExtensionMonth(extensionMonth);
+
+				// 费用
+				String extensionPrice = BigDecimal.valueOf(Double.valueOf(taUserLicense.getUnitPrice()) / 100).multiply(BigDecimal.valueOf(extensionMonth)).toString();
+				String price = String.valueOf(Double.valueOf(extensionPrice) * 100);
+				taUserLicenseOrder.setExtensionPrice(price.substring(0, price.lastIndexOf(".")));
+
+				taUserLicenseOrder.setPaymentTel(taUser.getLoginName());
+				taUserLicenseOrder.setPaymentName(taUser.getUserName());
+				taUserLicenseOrder.setPaymentType(paymentType);
+
+				// 到期时间 (具体的到期时候，在支付回调里面以车辆管理系统为准)
+				LocalDateTime localDateTime = LocalDateTime.ofInstant(taUserLicense.getExpireDate().toInstant(), ZoneId.systemDefault());
+				localDateTime.plusMonths(extensionMonth);
+				taUserLicenseOrder.setExpireDate(Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant()));
+				taUserLicenseOrder.setUnitPrice(taUserLicense.getUnitPrice());
+				taUserLicenseOrder.setParkingLot(taUserLicense.getParkingLot());
+				taUserLicenseOrder.setLicensePlate(taUserLicense.getLicensePlate());
+
+				// 插入数据
+				taUserLicenseOrderMapper.insertSelective(taUserLicenseOrder);
 
-		// 修改缴费人
-		 updateBillInvoiceBillStatus(billInvoiceIdArray, taUser.getUserName(), "3");
-		return orderNo;
+			}
+
+		}
 	}
-	
+
+
+
 	/**
 	 * 取消支付
 	 *
 	 */
 	@Override
 	@Transactional(rollbackFor = Exception.class)
-	public void wxCancelPay(String outTradeNo, UserElement userElement) throws Exception {
+	public void wxCancelPay(String outTradeNo, String type, UserElement userElement) throws Exception {
+
+		/**
+		 * 如果是车缴费订单，就只直接更新 订单状态为关闭
+		 */
+		// 如果是车缴费
+		if (Constant.PAY_TYPE_CAR.equals(type)) {
+			// 更改订单状态 为订单已关闭
+			updateOrderStatus(outTradeNo, type, "3");
+			return;
+		}
+
+		// --------------------------- 物业缴费 --------------------------------
 
 		//获取支付金额
 		List<TpBillOrder> billOrderList = tpBillOrderMapper.selectByOrderBumber(outTradeNo);
 		List<TpBillInvoice> billInvoiceList = Lists.newArrayList();
 		for (TpBillOrder tpBillOrder : billOrderList) {
 			TpBillInvoice billInvoice = tpBillInvoiceMapper.selectByPrimaryKey(tpBillOrder.getTpBillInvoiceId());
-			if (!billInvoice.getBillStatus().equals("3")){
+			if (!billInvoice.getBillStatus().equals("2")){
 				throw new Exception("不是正在支付的订单");
 			}
 			billInvoiceList.add(billInvoice);
 
 		//更新为 未支付状态
 		updateBillInvoiceBillStatus(billInvoiceIdList, "","0");
-		log.info("订单: {}， 状态变更为取消支付", outTradeNo);
+		log.info("订单: {}， 订单类型: {}, 状态变更为取消支付", outTradeNo, type);
 
 		// 更改订单状态 为订单已关闭
-		List<TpBillOrder> billOrders = tpBillOrderMapper.selectByOrderBumber(outTradeNo);
-		billOrders.forEach(e-> {
-			e.setOrderStatus("3");
-			tpBillOrderMapper.updateByPrimaryKeySelective(e);
+		updateOrderStatus(outTradeNo, type, "3");
+
+	}
+
+	@Override
+	public String wxCarNotify(Map<String, String> resultMap) {
+
+		String outTradeNo = resultMap.get("out_trade_no");
+		String pay_type = resultMap.get("pay_type");
+		String payTypeName = pay_type.equals("0") ? "微信支付" : pay_type.equals("2") ? "支付宝" : "未知";
+
+		List<TaUserLicenseOrder> userLicenseOrderList = taUserLicenseOrderMapper.selectByOrderNumber(outTradeNo);
+		if (CollectionUtils.isEmpty(userLicenseOrderList)){
+			return "不存在的订单";
+		}
+
+		log.info("订单：{},订单类型: {} 开始推送到 车辆管理系统 ", outTradeNo, Constant.PAY_TYPE_CAR);
+
+		TaUserLicenseOrder taUserLicenseOrder = userLicenseOrderList.get(0);
+		TaUser taUser = taUserMapper.selectByPrimaryKey(taUserLicenseOrder.getTaUserId());
+
+		// 推送到车辆管理系统
+		iFuShiService.apiThirdPartyMonthCardPay(taUser.getLoginName(), "2",
+				String.valueOf(taUserLicenseOrder.getExtensionMonth()),
+				payTypeName, taUserLicenseOrder.getLicensePlate(),
+				null, String.valueOf(Double.valueOf(taUserLicenseOrder.getExtensionPrice()) / 100));
+
+
+		userLicenseOrderList.forEach(e-> {
+			e.setPaymentType(pay_type);
+			UserElement userElement = new UserElement();
+			userElement.setCommunityId(e.getCommunityId());
+			userElement.setId(e.getTaUserId());
+			ResponseBean responseLicense = iTaUserLicenseService.getLicense(userElement, e.getLicensePlate());
+			Object licenseData = responseLicense.getData();
+			TaUserLicense taUserLicense = null;
+			if (null != licenseData && licenseData instanceof TaUserLicense) {
+				taUserLicense = (TaUserLicense) licenseData;
+			}
+
+			e.setExpireDate(taUserLicense.getExpireDate());
+
+			taUserLicenseOrderMapper.updateByPrimaryKeySelective(e);
+
 		});
+
+
+		log.info("订单: {}，订单类型: {}, 状态变更为支付成功", outTradeNo, Constant.PAY_TYPE_CAR);
+
+		// 更改订单状态 为支付成功
+		updateOrderStatus(outTradeNo, Constant.PAY_TYPE_CAR, "1");
+
+		return "success";
 	}
-	
+
 	/**
 	 * 更新支付状态
 	 * @param billInvoiceIdList
-	 * @param billStatus
+	 * @param status
 	 */
-	private void updateBillInvoiceBillStatus(List<Integer> billInvoiceIdList, String billStatus) {
+	private void updateBillInvoiceBillStatus(List<Integer> billInvoiceIdList, String status) {
 		billInvoiceIdList.forEach(e -> {
 			TpBillInvoice tpBillInvoiceUpdate = new TpBillInvoice();
-			tpBillInvoiceUpdate.setBillStatus(billStatus);
+			tpBillInvoiceUpdate.setBillStatus(status);
 			tpBillInvoiceUpdate.setId(e);
 			tpBillInvoiceMapper.updateByPrimaryKeySelective(tpBillInvoiceUpdate);
 		});
 	 * 更新支付状态
 	 * @param billInvoiceIdList
 	 * @param userName 缴费人
-	 * @param billStatus
+	 * @param status
 	 */
-	private void updateBillInvoiceBillStatus(List<Integer> billInvoiceIdList, String userName, String billStatus) {
+	private void updateBillInvoiceBillStatus(List<Integer> billInvoiceIdList, String userName, String status) {
 		billInvoiceIdList.forEach(e -> {
 			TpBillInvoice tpBillInvoiceUpdate = new TpBillInvoice();
-			tpBillInvoiceUpdate.setBillStatus(billStatus);
+			tpBillInvoiceUpdate.setBillStatus(status);
 			tpBillInvoiceUpdate.setId(e);
 			tpBillInvoiceUpdate.setPayName(userName);
 			tpBillInvoiceMapper.updateByPrimaryKeySelective(tpBillInvoiceUpdate);
 		});
+	}
 
+	/**
+	 * 更改订单状态
+	 * @param orderNumber
+	 * @param type
+	 * @param status
+	 */
+	private void updateOrderStatus(String orderNumber, String type, String status){
+		// 物业缴费
+		if (Constant.PAY_TYPE_BILL.equals(type)) {
+			List<TpBillOrder> billOrders = tpBillOrderMapper.selectByOrderBumber(orderNumber);
+			billOrders.forEach(e-> {
+				e.setOrderStatus(status);
+				tpBillOrderMapper.updateByPrimaryKeySelective(e);
+			});
+
+			// 车缴费
+		} else if (Constant.PAY_TYPE_CAR.equals(type)) {
+			List<TaUserLicenseOrder> taUserLicenseOrders = taUserLicenseOrderMapper.selectByOrderNumber(orderNumber);
+			taUserLicenseOrders.forEach(e-> {
+				e.setOrderStatus(status);
+				taUserLicenseOrderMapper.updateByPrimaryKeySelective(e);
+			});
+		}
 	}
 }

CODE/smart-community/app-api/src/main/resources/application.yml

 
 # 支付回调
 pay-notify:
-  wx-bill-notify: http://106.14.20.193:8086/app-api/wxNotify
-  ali-bill-notify: http://106.14.20.193:8086/app-api/aliPayNotify
-#  wx-bill-notify: http://ycapi.jcjyhn.com/app-api/wxNotify
-#  ali-bill-notify: http://ycapi.jcjyhn.com/app-api/aliPayNotify
+  wx-bill-notify: http://106.14.20.193:8086/app-api/wxBillNotify
+  ali-bill-notify: http://106.14.20.193:8086/app-api/aliPayBillNotify
+  wx-car-notify: http://106.14.20.193:8086/app-api/wxCarNotify
+  ali-car-notify: http://106.14.20.193:8086/app-api/aliPayCarNotify
+#  wx-bill-notify: http://ycapi.jcjyhn.com/app-api/wxBillNotify
+#  ali-bill-notify: http://ycapi.jcjyhn.com/app-api/aliPayBillNotify
+#  wx-car-notify: http://ycapi.jcjyhn.com/app-api/wxCarNotify
+#  ali-car-notify: http://ycapi.jcjyhn.com/app-api/aliPayCarNotify
 
 # 大苏
 da-su:

CODE/smart-community/community-common/src/main/java/com/community/commom/constant/Constant.java

 
     /** 用户待审核 **/
     public static final String TO_AUDIT = "0";
+
+    /** 缴费类型 物业 **/
+    public static final String PAY_TYPE_BILL = "bill";
+
+
+    /** 缴费类型 车缴费 **/
+    public static final String PAY_TYPE_CAR = "car";
 }

CODE/smart-community/property-api/src/main/java/com/community/huiju/controller/TpShopTypeController.java

 import io.swagger.annotations.ApiOperation;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.cloud.context.config.annotation.RefreshScope;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 import javax.servlet.http.HttpSession;
+import java.time.LocalDateTime;
 
 /**
  * <p>
 		responseBean = shopTypeService.getTypesList(userElement.getCommunityId(),pageNum,pageSize);
 		return responseBean;
 	}
+	
+	@ApiOperation(value = "添加商铺类型", notes = "添加商铺类型")
+	@ApiImplicitParams({
+			@ApiImplicitParam(paramType = "body", dataType = "TpShopType", name = "shopType", value = "商铺类型"),
+			@ApiImplicitParam(paramType = "header", dataTypeClass = String.class, name = "X-Auth-Token", value = "Token")
+	})
+	@RequestMapping(value = "/shop/add/type",method = RequestMethod.POST)
+	public ResponseBean saveShopType(@RequestBody TpShopType shopType, HttpSession session){
+		ResponseBean responseBean = new ResponseBean();
+		UserElement userElement = getUserElement(session);
+		shopType.setCommunityId(userElement.getCommunityId());
+		shopType.setSource("self");
+		shopType.setCreateUser(userElement.getId());
+		shopType.setCreateDate(LocalDateTime.now());
+		boolean state  = shopTypeService.save(shopType);
+		if (state){
+			responseBean.addSuccess("添加成功");
+		}else{
+			responseBean.addError("添加失败");
+		}
+		return responseBean;
+	}
+	
+	@ApiOperation(value = "获取商铺类型", notes = "获取商铺类型")
+	@ApiImplicitParams({
+			@ApiImplicitParam(paramType = "path", dataType = "Integer", name = "id", value = "商铺类型Id"),
+			@ApiImplicitParam(paramType = "header", dataTypeClass = String.class, name = "X-Auth-Token", value = "Token")
+	})
+	@RequestMapping(value = "/shop/get/type/{id}",method = RequestMethod.GET)
+	public ResponseBean getShopType(@PathVariable Integer id, HttpSession session){
+		ResponseBean responseBean = new ResponseBean();
+		UserElement userElement = getUserElement(session);
+		TpShopType tpShopType = shopTypeService.getById(id);
+		responseBean.addSuccess(tpShopType);
+		return responseBean;
+	}
+	
+	@ApiOperation(value = "更新商铺类型", notes = "更新商铺类型")
+	@ApiImplicitParams({
+			@ApiImplicitParam(paramType = "body", dataType = "TpShopType", name = "shopType", value = "商铺类型"),
+			@ApiImplicitParam(paramType = "header", dataTypeClass = String.class, name = "X-Auth-Token", value = "Token")
+	})
+	@RequestMapping(value = "/shop/update/type",method = RequestMethod.POST)
+	public ResponseBean updateShopType(@RequestBody TpShopType shopType, HttpSession session){
+		ResponseBean responseBean = new ResponseBean();
+		UserElement userElement = getUserElement(session);
+		boolean state  = shopTypeService.updateById(shopType);
+		if (state){
+			responseBean.addSuccess("更新成功");
+		}else{
+			responseBean.addError("更新失败");
+		}
+		return responseBean;
+	}
+	
+	@ApiOperation(value = "删除商铺类型", notes = "删除商铺类型")
+	@ApiImplicitParams({
+			@ApiImplicitParam(paramType = "body", dataType = "String", name = "jsonString", value = "商铺id集合"),
+			@ApiImplicitParam(paramType = "header", dataTypeClass = String.class, name = "X-Auth-Token", value = "Token")
+	})
+	@RequestMapping(value = "/shop/delete/type",method = RequestMethod.DELETE)
+	public ResponseBean deleteShopType(@RequestBody String jsonString, HttpSession session){
+		ResponseBean responseBean = new ResponseBean();
+		responseBean = shopTypeService.deleteShopType(jsonString);
+		return responseBean;
+	}
 }

CODE/smart-community/property-api/src/main/java/com/community/huiju/model/TpShopSetting.java

 package com.community.huiju.model;
 
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
 public class TpShopSetting implements Serializable {
 
     private static final long serialVersionUID = 1L;
-
+    
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+    
     /**
      * 小区ID
      */

CODE/smart-community/property-api/src/main/java/com/community/huiju/model/TpShopType.java

 package com.community.huiju.model;
 
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.experimental.Accessors;
 public class TpShopType implements Serializable {
 
     private static final long serialVersionUID = 1L;
-
+    
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+    
     /**
      * 小区ID
      */

CODE/smart-community/property-api/src/main/java/com/community/huiju/service/ITpShopTypeService.java

 	 * @return
 	 */
 	ResponseBean getTypesList(Integer communityId, Integer pageNum, Integer pageSize);
+	
+	/**
+	 * 删除商铺类型
+	 * @param jsonString
+	 * @return
+	 */
+	ResponseBean deleteShopType(String jsonString);
 }

CODE/smart-community/property-api/src/main/java/com/community/huiju/service/impl/TpShopTypeServiceImpl.java

 package com.community.huiju.service.impl;
 
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 		//获取列表数据
 		QueryWrapper<TpShopType> queryWrapper = new QueryWrapper<>();
 		queryWrapper.eq("community_id",communityId);
+		queryWrapper.orderByAsc("sort");
+		queryWrapper.orderByAsc("create_date");
 		IPage<TpShopType> myPage = shopTypeMapper.selectPage(page,queryWrapper);
 		//获取商铺是否app显示
 		QueryWrapper<TpShopSetting> settingQueryWrapper = new QueryWrapper<>();
 		TpShopSetting shopSetting = shopSettingMapper.selectOne(settingQueryWrapper);
 		Map<String,Object> map = new HashMap<>();
 		map.put("dataList",myPage.getRecords());
-		map.put("pageNum",myPage.getCurrent());
-		map.put("pageSize",myPage.getPages());
 		map.put("total",myPage.getTotal());
 		map.put("shopSettingValue",null == shopSetting ? false : true);
 		responseBean.addSuccess(map);
 		return responseBean;
 	}
+	
+	/**
+	 * 删除商铺类型
+	 *
+	 * @param jsonString
+	 * @return
+	 */
+	@Override
+	public ResponseBean deleteShopType(String jsonString) {
+		ResponseBean responseBean = new ResponseBean();
+		StringBuffer message = new StringBuffer();
+		message.append("删除成功。");
+		JSONObject jsonObject = JSONObject.parseObject(jsonString);
+		JSONArray ids = jsonObject.getJSONArray("idArray");
+		for (Object id : ids){
+			//根据ID查询这个数据是否是系统创建，系统创建的不能删除，非系统创建的能删除
+			TpShopType shopType = shopTypeMapper.selectById(id.toString());
+			if (shopType.getSource().equals("sys")){
+				//系统创建不可删除
+				message.append(shopType.getTypeName() + "为系统创建，不可删除。");
+			}else{
+				shopTypeMapper.deleteById(id.toString());
+			}
+		}
+		responseBean.addSuccess(message.toString());
+		return responseBean;
+	}
 }

VUECODE/smart-property-manage/src/api/shopType.js

     }
   })
 }
+
+export function addShopType(listQuery) {
+  return request({
+    url: '/shop/add/type',
+    method: 'post',
+    data: listQuery
+  })
+}
+
+export function getShopType(id) {
+  return request({
+    url: '/shop/get/type/' + id,
+    method: 'get'
+  })
+}
+
+export function updateShopType(listQuery) {
+  return request({
+    url: '/shop/update/type',
+    method: 'post',
+    data: listQuery
+  })
+}
+
+export function deleteShopType(ids) {
+  return request({
+    url: '/shop/delete/type',
+    method: 'delete',
+    data: {
+      idArray: ids
+    }
+  })
+}
+

VUECODE/smart-property-manage/src/router/index.js

         name: 'shop-setting',
         meta: { title: '商铺配置', icon: 'table' }
       },
+      {
+        path: '/shop/setting/add',
+        component: () => import('@/views/shop/shopSettingAdd'),
+        name: 'shopSetting-add',
+        hidden: true,
+        meta: { title: '添加商铺类型', icon: 'table' }
+      },
+      {
+        path: '/shop/setting/edit',
+        component: () => import('@/views/shop/shopSettingEdit'),
+        name: 'shopSetting-edit',
+        hidden: true,
+        meta: { title: '修改商铺类型', icon: 'table' }
+      },
       {
         path: '/shop/index',
         component: () => import('@/views/shop/shopIndex'),

VUECODE/smart-property-manage/src/store/modules/shopType.js

-import { fetchShopTypeList, changeShopSetting } from '@/api/shopType'
+import { fetchShopTypeList, changeShopSetting, addShopType, getShopType, updateShopType, deleteShopType } from '@/api/shopType'
 
 const transaction = {
   namespaced: true,
           reject(error)
         })
       })
+    },
+    AddShopType({ commit }, listQuery) {
+      return new Promise((resolve, reject) => {
+        addShopType(listQuery).then(response => {
+          resolve(response)
+        }).catch(error => {
+          reject(error)
+        })
+      })
+    },
+    GetShopType({ commit }, id) {
+      return new Promise((resolve, reject) => {
+        getShopType(id).then(response => {
+          resolve(response)
+        }).catch(error => {
+          reject(error)
+        })
+      })
+    },
+    UpdateShopType({ commit }, listQuery) {
+      return new Promise((resolve, reject) => {
+        updateShopType(listQuery).then(response => {
+          resolve(response)
+        }).catch(error => {
+          reject(error)
+        })
+      })
+    },
+    DeleteShopType({ commit }, ids) {
+      return new Promise((resolve, reject) => {
+        deleteShopType(ids).then(response => {
+          resolve(response)
+        }).catch(error => {
+          reject(error)
+        })
+      })
     }
   }
 }

VUECODE/smart-property-manage/src/views/shop/shopSetting.vue

     <div class="button">
       <el-button type="primary" @click="add">添加</el-button>
       <el-button type="warning" @click="edit">修改</el-button>
-      <el-button type="danger" @click="deleteAnnouncement">删除</el-button>
+      <el-button type="danger" @click="deleteShopType">删除</el-button>
     </div>
     <el-table
       v-loading="listLoading"
       <el-table-column prop="typeName" label="商铺类型" align="center"/>
       <el-table-column prop="sort" label="权重" align="center"/>
       <el-table-column prop="createDate" label="发布时间" align="center"><template slot-scope="scope">{{ formatDate(scope.row.createDate) }}</template></el-table-column>
-      <el-table-column prop="createUserName" label="发布人" align="center"/>
-      <el-table-column prop="updateDate" label="修改时间" align="center" ><template slot-scope="scope">{{ formatDate(scope.row.updateDate) }}</template></el-table-column>
-      <el-table-column prop="updateDateName" label="修改人" align="center"/>
     </el-table>
     <div class="block">
       <el-pagination
       this.listLoading = true
       this.FetchShopTypeList(this.listQuery).then((resData) => {
         this.shopTypeList = resData.dataList
-        this.listQuery.pageNum = resData.pageNum
-        this.listQuery.pageSize = resData.pageSize
         this.total = resData.total
         this.shopSettingValue = resData.shopSettingValue
         this.listLoading = false
     },
     // 添加公告
     add() {
-      this.$router.push({ name: 'announcement-add' })
+      this.$router.push({ name: 'shopSetting-add' })
     },
     edit(){// 编辑公告
       const ids = this.deleteIds
       }
        let ide= this.deleteIds[0]
        this.listQuery.id = ide
-      this.$store.dispatch('AnnouncementById', this.listQuery).then((res) => {
-        const resData = res.data
-        const announcement = resData.tpAnnouncement
-        const imgList = resData.studentList
-        this.listQuery = announcement
-        this.listQuery.announcementTitle = ''
-        console.log("1",this.listQuery.status)
-        if(this.listQuery.status == 0){
-          this.$message.error('已作废不可以修改')
-          return
-        } 
-       this.$router.push({ name: 'announcement-edit', query: { id: ide }})
-      }) 
-      },
-    deleteAnnouncement(){
-       let ide= this.deleteIds[0]
-       this.listQuery.id = ide 
-      this.$store.dispatch('AnnouncementById', this.listQuery).then((res) => {
-        const resData = res.data
-        const announcement = resData.tpAnnouncement
-        const imgList = resData.studentList
-        this.listQuery.status= announcement.status
-        console.log("1",this.listQuery.status)
-        if(this.listQuery.status == 0){
-          this.$message.error('已作废不可以作废')
-          return
-        }
-        this.deleteId()     
-      })    
+       this.$router.push({ name: 'shopSetting-edit', query: { id: ide }})
     },
-
-    deleteId(){
-       const ids = this.deleteIds
+    deleteShopType(){
+      const ids = this.deleteIds
       this.listLoading = true
-      console.log(ids)
-      this.$store.dispatch('DeleteAnnouncement', ids).then((res) => {
+      this.$store.dispatch('shopType/DeleteShopType', ids).then((res) => {
         this.listLoading = false
-        this.listQuery.announcementTitle = ''
+        this.$message({
+          message: res.message,
+          type: 'success'
+        })
         this.dataQuery()
       }).catch(() => {
         this.listLoading = false
-        console.log('error DeleteAnnouncement')
+        console.log('error DeleteShopType')
       })
     },
-
-
     clickTitle(id) {
       this.$router.push({ name: 'contentParticulars-details', query: { id: id }})
     },

VUECODE/smart-property-manage/src/views/shop/shopSettingAdd.vue

+<template>
+  <div class="root">
+    <el-form ref="ruleForm" :model="listQuery" :rules="rules" label-width="100px" class="add-ruleForm">
+      <el-form-item label="商铺类型" prop="typeName">
+        <el-input v-model="listQuery.typeName" style="width: 200px;"/>
+      </el-form-item>
+      <el-form-item label="权重" prop="sort">
+        <el-input v-model="listQuery.sort" style="width: 200px;"/>
+      </el-form-item>
+      <el-form-item>
+        <el-button type="primary" @click="submitForm('ruleForm')">立即创建</el-button>
+        <el-button @click="resetForm('ruleForm')">重置</el-button>
+      </el-form-item>
+    </el-form>
+  </div>
+</template>
+
+<script>
+export default {
+  data() {
+    return {
+      listQuery: {
+        typeName: '',
+        sort: ''
+      },
+      rules: {
+        typeName: [
+          { required: true, message: '请输入商铺类型', trigger: 'blur' }
+        ]
+      }
+    }
+  },
+  mounted() {
+  },
+  methods: {
+    submitForm(formName) { // 提交
+      this.$refs[formName].validate((valid) => {
+        if (valid) {
+          this.addBuilding()
+        } else {
+          console.log('error submit!!')
+          return false
+        }
+      })
+    },
+    resetForm(formName) { // 重置
+      // 重置为未注册
+      this.isRegistered = true
+      // 重置为非户主
+      this.roleDisabled = false
+
+      console.log(this.isRegistered)
+      this.$refs[formName].resetFields()
+    },
+    addBuilding() {
+      // 加载框
+      const loading = this.$loading({
+        lock: true,
+        text: 'Loading',
+        spinner: 'el-icon-loading',
+        background: 'rgba(0, 0, 0, 0.7)'
+      })
+      this.$store.dispatch('shopType/AddShopType', this.listQuery).then((res) => {
+        if (res.code === '0') {
+          this.$message({
+            message: res.message,
+            type: 'success'
+          })
+          this.$router.push({ name: 'shop-setting' })
+          loading.close()
+          return
+        }
+        this.$message.error(res.message)
+        loading.close()
+      }).catch(() => {
+        loading.close()
+        console.log('error AddBuilding')
+      })
+    }
+  }
+}
+</script>
+
+<style scoped>
+.add-ruleForm{
+  width: 800px;
+  margin-left: auto;
+  margin-right: auto;
+  margin-top: 50px;
+}
+</style>

VUECODE/smart-property-manage/src/views/shop/shopSettingEdit.vue

+<template>
+  <div class="root">
+    <el-form ref="ruleForm" :model="listQuery" :rules="rules" label-width="100px" class="add-ruleForm">
+      <el-form-item label="商铺类型" prop="typeName">
+        <el-input v-model="listQuery.typeName" style="width: 200px;"/>
+      </el-form-item>
+      <el-form-item label="权重" prop="sort">
+        <el-input v-model="listQuery.sort" style="width: 200px;"/>
+      </el-form-item>
+      <el-form-item>
+        <el-button type="primary" @click="submitForm('ruleForm')">修改</el-button>
+      </el-form-item>
+    </el-form>
+  </div>
+</template>
+
+<script>
+export default {
+  data() {
+    return {
+      listQuery: {
+        id: '',
+        typeName: '',
+        sort: ''
+      },
+      rules: {
+        typeName: [
+          { required: true, message: '请输入商铺类型', trigger: 'blur' }
+        ]
+      }
+    }
+  },
+  mounted() {
+    this.listQuery.id = this.$route.query.id
+    this.getById()
+  },
+  methods: {
+    submitForm(formName) { // 提交
+      this.$refs[formName].validate((valid) => {
+        if (valid) {
+          this.updateBuilding()
+        } else {
+          console.log('error submit!!')
+          return false
+        }
+      })
+    },
+    resetForm(formName) { // 重置
+      // 重置为未注册
+      this.isRegistered = true
+      // 重置为非户主
+      this.roleDisabled = false
+
+      console.log(this.isRegistered)
+      this.$refs[formName].resetFields()
+    },
+    getById() {
+      this.$store.dispatch('shopType/GetShopType', this.listQuery.id).then((res) => {
+        console.log(res)
+        const typeData = res.data
+        this.listQuery.typeName = typeData.typeName
+        this.listQuery.sort = typeData.sort
+      })
+    },
+    updateBuilding() {
+      // 加载框
+      const loading = this.$loading({
+        lock: true,
+        text: 'Loading',
+        spinner: 'el-icon-loading',
+        background: 'rgba(0, 0, 0, 0.7)'
+      })
+      this.$store.dispatch('shopType/UpdateShopType', this.listQuery).then((res) => {
+        if (res.code === '0') {
+          this.$message({
+            message: res.message,
+            type: 'success'
+          })
+          this.$router.push({ name: 'shop-setting' })
+          loading.close()
+          return
+        }
+        this.$message.error(res.message)
+        loading.close()
+      }).catch(() => {
+        loading.close()
+        console.log('error updateBuilding')
+      })
+    }
+  }
+}
+</script>
+
+<style scoped>
+.add-ruleForm{
+  width: 800px;
+  margin-left: auto;
+  margin-right: auto;
+  margin-top: 50px;
+}
+</style>