コード例 #1
0
  /**
   * 分页查询订单列表
   *
   * @param query
   * @return
   */
  @RequestMapping(value = "/query/pageGetOrders", method = RequestMethod.POST)
  @ResponseBody
  public RestResultDTO pageGetPartialFiledsViewListByQuery(OrderQuery query) {
    RestResultDTO restResponse = new RestResultDTO();
    query.setId(null);
    query.setMemberName(null);
    query.setOrderCode(null);
    try {
      CommonValidateUtil.notEmpty(query.getMemberPin(), "会员不能为空");
      PaginatedList<PartialFiledsOrderVO> list =
          orderRelatedQueryService.pageGetPartialFiledsViewListByQuery(query);
      PageList<PartialFiledsOrderVO> pageList =
          new PageList<PartialFiledsOrderVO>(
              list.getPageSize(),
              list.getIndex(),
              list.getTotalItem(),
              list.getTotalPage(),
              list.isFirstPage(),
              list.isLastPage(),
              list);
      restResponse.setBody(pageList);
      restResponse.initStatus(StatusCode.OK);
    } catch (Exception e) {
      exceptionDeal(restResponse, e, "pageGetPartialFiledsViewListByQuery", "查询订单列表失败");
    }

    return restResponse;
  }
コード例 #2
0
  /**
   * 订单支付成功确认
   *
   * @param orderCode
   * @param memberPin
   * @param payChannel
   * @param payCode
   * @param payTime
   * @return
   */
  @RequestMapping(value = "/update/orderPaySuccessConfirm", method = RequestMethod.POST)
  @ResponseBody
  public RestResultDTO orderPaySuccessConfirm(
      String memberPin,
      String orderCode,
      Integer payMoney,
      Integer payChannel,
      String payCode,
      String payTime) {
    RestResultDTO restResultDTO = new RestResultDTO();
    try {
      CommonValidateUtil.notEmpty(memberPin, "会员不能为空");
      if (!CommonValidateUtil.validateFixedLengthDigital(orderCode, 20)) {
        throw new IllegalArgumentException("请输入正确的订单号");
      }

      Validate.notNull(payMoney, "支付金额不能为空");

      if (payMoney <= 0) {
        throw new IllegalArgumentException("请输入正确的支付金额");
      }

      Validate.notNull(payChannel, "支付渠道不能为空");
      Validate.notNull(OrderPayChannelEnum.get(payChannel), "支付渠道不能为空");

      if (!CommonValidateUtil.validateRangeLengthStr(payCode, 1, 50)) {
        throw new IllegalArgumentException("支付编码不能为空");
      }
      CommonValidateUtil.notEmpty(payTime, "支付时间不能为空");

      restResultDTO =
          orderCreateAndPayService.orderPaySuccessConfirm(
              memberPin,
              orderCode,
              payMoney,
              payChannel,
              payCode,
              DateOperator.parse(payTime, "yyyyMMddHHmmss"));

      /*----- 校验订单上的产品副本是否已和保险公司对接成功 -----*/
      Order order = orderRelatedQueryService.getByOrderCode(orderCode);

      if (order != null && order.getId() != null) {
        if (!order.getProductDocked())
          restResultDTO.setBody(CustomCode.NO_CALL_AUTOMATIC_INS_ACCEPT_INTER);
      }

    } catch (Exception e) {
      exceptionDeal(restResultDTO, e, "orderPaySuccessConfirm", "订单支付成功确认失败");
    }

    return restResultDTO;
  }
コード例 #3
0
  /**
   * 订单支付失败确认
   *
   * @param memberPin
   * @param orderCode
   * @param reason
   * @return
   */
  @RequestMapping(value = "/update/orderPayFailureConfirm", method = RequestMethod.POST)
  @ResponseBody
  public RestResultDTO orderPayFailureConfirm(String memberPin, String orderCode, String reason) {
    RestResultDTO restResultDTO = new RestResultDTO();
    try {
      CommonValidateUtil.notEmpty(memberPin, "会员不能为空");
      if (!CommonValidateUtil.validateFixedLengthDigital(orderCode, 20)) {
        throw new IllegalArgumentException("请输入正确的订单号");
      }

      if (!CommonValidateUtil.validateRangeLengthStr(reason, 1, 50)) {
        throw new IllegalArgumentException("请输入正确的失败原因");
      }
      orderCreateAndPayService.orderPayFailureConfirm(memberPin, orderCode, reason);
      restResultDTO.initStatus(StatusCode.OK);
    } catch (Exception e) {
      exceptionDeal(restResultDTO, e, "orderPayFailureConfirm", "订单支付失败确认失败");
    }
    return restResultDTO;
  }
コード例 #4
0
 @RequestMapping(value = "/query/getOrderDetail", method = RequestMethod.POST)
 @ResponseBody
 public RestResultDTO getDetail(String orderCode, String memberPin) {
   RestResultDTO restResponse = new RestResultDTO();
   try {
     CommonValidateUtil.notEmpty(memberPin, "会员不能为空");
     if (CommonValidateUtil.validateFixedLengthDigital(orderCode, 20)) {
       // Order entity = orderRelatedQueryService.getByOrderCodeAndMemPin(orderCode, memberPin);
       Order entity = orderRelatedQueryService.getByOrderCode(orderCode);
       if (entity != null && entity.getMemberPin().equals(memberPin)) {
         restResponse.setBody(new OrderVO(entity));
       }
     }
     restResponse.initStatus(StatusCode.OK);
     // logRequest(request.getRemoteAddr(), "查询订单[订单号]", orderCode, "成功");
   } catch (Exception e) {
     exceptionDeal(restResponse, e, "getDetail", "查询订单失败[订单号]");
   }
   return restResponse;
 }
コード例 #5
0
  /**
   * 订单可否支付确认
   *
   * @param request
   * @param orderCode
   * @return
   */
  @RequestMapping(value = "/query/orderBePaidConfirm", method = RequestMethod.POST)
  @ResponseBody
  public RestResultDTO orderBePaidConfirm(String orderCode) {
    RestResultDTO restResultDTO = new RestResultDTO();
    try {
      if (!CommonValidateUtil.validateFixedLengthDigital(orderCode, 20)) {
        throw new IllegalArgumentException("请输入正确的订单号");
      }

      Order order = orderRelatedQueryService.getByOrderCode(orderCode);
      restResultDTO.initStatus(StatusCode.OK);
      if (order != null) {
        if (order.getOrderStatus() == OrderStatusEnum.CREATED.getValue()) {
          restResultDTO.setBody(JhjMoneyUtil.getInstance().getMoneyString(order.getTotalPrice()));
        } else {
          restResultDTO.initStatus(StatusCode.INTERNAL_SERVER_ERROR);
          restResultDTO.setMessage("订单已支付或已关闭,不能再支付");
        }
      } else {
        restResultDTO.initStatus(StatusCode.NOT_FOUND);
      }
    } catch (Exception e) {
      exceptionDeal(restResultDTO, e, "orderBePaidConfirm", "订单可否支付确认失败");
    }

    return restResultDTO;
  }