完成缴费

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/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

     @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);
 }

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");
+
+			// 车缴费
+		} else if (Constant.PAY_TYPE_CAR.equals(type)) {
+			if (null == extensionMonth && extensionMonth > 0) {
+				throw new Exception("延期月份不能为空，并且要大于0!");
 			}
 
-			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");
+			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;
+				}
 
-			tpBillOrderMapper.insertSelective(tpBillOrder);
+				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 "不存在的订单";
+		}
+
+		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");
+
+		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));
+
+		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";
 }