收银机查询商品列表及详情接口

获取收银订单列表信息

controller层
返回结果全部封装在VO中，分页查询，查询时传入参数全部封装在request中

    @PostMapping("queryOrder")
    public RestResult<PageListVO<PosOrderListVO>> queryOrderList(@RequestBody PosQueryOrderByIdRequest request) {
        //参数校验
        if (request.getBizChannel() != null && request.getSellerId() != null) {
            OrderListQueryBySellerParam orderListQueryBySellerParam = OrderVoConvert.convertRequestById(request);
            PageListDTO<OrderResultDTO> pages = orderQueryService.queryOrderListBySeller(orderListQueryBySellerParam);
            return RestResult.buildSuccessResult(OrderVoConvert.convertToVO(pages));
        } else {
            return RestResult.buildFailureResult(0, "error");
        }
    }

service层
返回结果全部封装再DTO中，传入参数全部分装在param中

  /**
     * 根据卖家查询订单(分页查询)
     * @param orderListQueryBySellerParam
     * @return
     */
    public PageListDTO<OrderResultDTO> queryOrderListBySeller(OrderListQueryBySellerParam orderListQueryBySellerParam) {
        log.info("queryOrderListBySeller Param"+orderListQueryBySellerParam);
        int totalCount = orderManager.queryOrderListBySellerCount(orderListQueryBySellerParam);
        List<OrderResultDTO> results = new ArrayList<>(10);
        if (totalCount > 0) {
            results = orderManager.queryOrderListBySeller(orderListQueryBySellerParam);
        }
        if (CollectionUtils.isNotEmpty(results)){
            getUserInfo(results);
        }
        log.info("queryOrderListBySeller返回结果"+results);
        PageListDTO<OrderResultDTO> pageListDTO = new PageListDTO<>();
        pageListDTO.setTotalCount(totalCount);
        pageListDTO.setListData(results);
        return pageListDTO;
    }

manager层
数据处理，通过判断传入的参数值来选择模糊查询的条件，因为有的字段在数据库存储位json，需要在manager层解析成实体类

    /**
     * 查询卖家订单列表
     *
     * @param orderListQueryBySellerParam
     * @return
     */
    public List<OrderResultDTO> queryOrderListBySeller(OrderListQueryBySellerParam orderListQueryBySellerParam) {
        OrderQuery query = OrderConvert.sellerQueryToDoQuery(orderListQueryBySellerParam);
        try {
            List<OrderResultDTO> orderResultDTOS = new ArrayList<>();
            if (query.getBizChannel() != null && query.getSellerId() != null) {
                if (query.getOrderIdString()!=null){
                    if (query.getOrderIdString().startsWith("9")){
                        query.setBizOrderId(query.getOrderIdString());
                        queryOrderListBySeller(query, orderResultDTOS);
                    }else{
                        query.setOrderId(Long.valueOf(query.getOrderIdString()));
                        queryOrderListBySeller(query, orderResultDTOS);
                    }
                }else{
                    queryOrderListBySeller(query,orderResultDTOS);
                }
            }
            return orderResultDTOS;
        } catch (Exception e) {
            throw new OrderException("参数异常");
        }
    }

    private void queryOrderListBySeller(OrderQuery query, List<OrderResultDTO> orderResultDTOS) {
        List<Order> orderList = mapper.queryOrderListBySeller(query);
        orderList.forEach(order -> {
            OrderResultDTO orderResultDTO = OrderConvert.orderToOrderResultDTO(order);
            orderResultDTO.setPaymentTypeName(PaymentTypeEnum.get(orderResultDTO.getPaymentType()).name);
            List<JsonExtOrderDiscountDTO> jsonExtOrderDiscountBeanList = JsonExtOrderDiscountBuild(order.getDiscountJson());
            orderResultDTO.setJsonExtOrderDiscounts(jsonExtOrderDiscountBeanList);
            orderResultDTOS.add(orderResultDTO);
        });
    }

mapper层
mapeer层的返回值一定是数据库表中的所有字段

    /**
     * 卖家订单列表查询
     */
    List<Order> queryOrderListBySeller(OrderQuery orderQuery);

xml文件

<select id="queryOrderListBySeller" parameterType="java.lang.Long" resultMap="BaseResultMap">
        <!--@mbg.generated-->
        select
        <include refid="Base_Column_List"/>
        from t_order
                WHERE biz_channel = #{bizChannel,jdbcType=INTEGER}
                  and seller_id = #{sellerId,jdbcType=INTEGER}
                  and order_status >= 15

        <if test="orderId != null and orderId != ''">
            AND order_id = #{orderId,jdbcType=BIGINT}
        </if>
        <if test="bizOrderId != null and bizOrderId != ''">
            AND biz_order_id = #{bizOrderId,jdbcType=VARCHAR}
        </if>
        <if test="startTime != null and startTime != ''">
            AND c_t <![CDATA[>=]]> #{startTime}
        </if>
        <if test="endTime != null and endTime != ''">
            AND c_t <![CDATA[<=]]> #{endTime}
        </if>
        order by c_t desc
            limit #{start}, #{end}

    </select>

获取收银订单详情信息

controller层（包含调用其他服务的接口）

@PostMapping("getOrderDetail")
    public RestResult<PosOrderDetailVO> getOrderDetail(@RequestBody PosQueryOrderDetailRequest request) {
        try {
            OrderResultDTO orderResultDTO = orderQueryService.queryOrderListByOrderId(OrderVoConvert.converToRequest(request));
            PosOrderMainVO posOrderMainVO = OrderVoConvert.converPosOrderMainDTO(orderResultDTO);
            if (orderResultDTO != null) {
                List<OrderQueryItemDTO> orderItems = orderQueryService.PosQueryOrderDetails(OrderVoConvert.converTOItemParam(request));
                BigDecimal totalItemDiscount =  orderItems.stream().map(OrderQueryItemDTO::getDiscountFactor).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
                posOrderMainVO.setTotalItemDiscountAmount(totalItemDiscount);
                List<PosOrderItemVO> posOrderItemVOList = OrderVoConvert.converToDto(orderItems);
                UserQueryParam userQueryParam = new UserQueryParam();
                userQueryParam.setUserId(orderResultDTO.getBuyerId());
                UserInfoBO userInfoBO = orderQueryService.callMemberService(userQueryParam);
                PosOrderDetailVO posOrderDetailVO = new PosOrderDetailVO();
                posOrderDetailVO.setOrderResultDTO(posOrderMainVO);
                posOrderDetailVO.setOrderItems(posOrderItemVOList);
                posOrderDetailVO.setVipUser(OrderVoConvert.converToUserVO(userInfoBO));
                return RestResult.buildSuccessResult(posOrderDetailVO);
            } else {
                return RestResult.buildFailureResult(0, "订单不存在");
            }
        } catch (Exception e) {
            return RestResult.buildFailureResult(0, "系统异常" + e.getMessage());
        }
    }

service层

    /**
     * 查询订单详情
     *
     * @param orderQueryItemParam
     * @return queryOrderItemDTOList
     */
    public List<OrderQueryItemDTO> PosQueryOrderDetails(OrderQueryItemParam orderQueryItemParam){
        OrderItemQuery orderItemQuery = new OrderItemQuery();
        orderItemQuery.setOrderId(orderQueryItemParam.getOrderId());
        List<OrderQueryItemBO> orderQueryItemBOList = orderItemManager.queryOrderDetail(orderItemQuery);
        List<OrderQueryItemDTO> orderQueryItemDTOList = OrderDtoConvert.orderItemBoToDTO(orderQueryItemBOList);
        CalculateReturnQuantity(orderItemQuery, orderQueryItemDTOList);
        log.info("订单详情返回参数"+orderQueryItemDTOList);
        return orderQueryItemDTOList;
    }





    /**
     * 通过售后单信息计算可退数量
     * @param queryOrderItemDTOList
     * @return
     */
    private List<OrderQueryItemDTO> CalculateReturnQuantity(OrderItemQuery orderItemQuery, List<OrderQueryItemDTO> queryOrderItemDTOList) {
        List<OrderAfterSellItemDTO> orderAfterSellItemDTOList = afterSellService.queryAfterSellItem(orderItemQuery.getOrderId());
        if (CollectionUtils.isEmpty(orderAfterSellItemDTOList)){
            queryOrderItemDTOList.forEach(orderQueryItemDTO -> {
                orderQueryItemDTO.setAlreadyReturnNum(BigDecimal.ZERO);
                orderQueryItemDTO.setReturnNum(orderQueryItemDTO.getOrderNum());
            });
            return queryOrderItemDTOList;
        }
        Map<Long, List<OrderAfterSellItemDTO>> orderAfterMap = orderAfterSellItemDTOList.stream().collect(Collectors.groupingBy(OrderAfterSellItemDTO::getOrderItemId));
        queryOrderItemDTOList.forEach(queryOrderItemDTO -> {
            List<OrderAfterSellItemDTO> afterSellItemDTOList = orderAfterMap.get(queryOrderItemDTO.getOrderItemId());
            if (!CollectionUtils.isEmpty(afterSellItemDTOList)){
                BigDecimal orderItemApplyNum = afterSellItemDTOList.stream().map(OrderAfterSellItemDTO::getApplyNum).reduce(BigDecimal::add).get();
                queryOrderItemDTO.setAlreadyReturnNum(orderItemApplyNum);
                queryOrderItemDTO.setReturnNum(queryOrderItemDTO.getOrderNum().subtract(orderItemApplyNum));
            }else{
                queryOrderItemDTO.setAlreadyReturnNum(BigDecimal.ZERO);
                queryOrderItemDTO.setReturnNum(queryOrderItemDTO.getOrderNum());
            }
        });
        return queryOrderItemDTOList;
    }


    /**
     * 调用会员服务
     * @param
     * @return
     */
    public UserInfoBO callMemberService(UserQueryParam userQueryParam){
        if (userQueryParam.getUserId() == null || userQueryParam.getUserId() == 0){
            return new UserInfoBO();
        }
        UserInfoRTO userInfoRTO = memberRepository.selectUserInfo(userQueryParam.getUserId());
        if (userInfoRTO != null){
            UserInfoBO userInfoBO = new UserInfoBO();
            userInfoBO.setVipNumber(userInfoRTO.getCardCode());
            userInfoBO.setPhoneNumber(userInfoRTO.getUser().getPhone());
            userInfoBO.setUserId(userQueryParam.getUserId().longValue());
            userInfoBO.setTomatoNum(userInfoRTO.getTomatoCoinNums().intValue());
            userInfoBO.setWalletAmount(userInfoRTO.getBalance());
            return userInfoBO;
        }else {
            return new UserInfoBO();
        }
    }

manager层

/**
 * 订单详情查询
 *
 * @param orderItemQuery
 * @return
 */
public List<OrderQueryItemBO> queryOrderDetail(OrderItemQuery orderItemQuery) {
    List<OrderItem> orderItemList = mapper.queryOrderDetailByOrderId(orderItemQuery.getOrderId());
    List<OrderQueryItemBO> orderQueryItemBOList = OrderDtoConvert.orderItemBoToOrderItem(orderItemList);
    orderQueryItemBOList.forEach(orderQueryItemBO -> {
        JsonExtOrderItemProportionDTO jsonExtOrderItemProportionDTOList = JSON.parseObject(orderQueryItemBO.getProportionJson(),JsonExtOrderItemProportionDTO.class);
        orderQueryItemBO.setJsonExtOrderItemProportionDTO(jsonExtOrderItemProportionDTOList);
    });
    return orderQueryItemBOList;
}

mapper层

    /**
     * 订单详情查询
     */
    List<OrderItem> queryOrderDetailByOrderId(@Param("orderId") Long orderId);

xml文件

<select id="queryOrderDetailByOrderId" parameterType="java.lang.Long" resultMap="BaseResultMap">
    select <include refid="Base_Column_List" /> from t_order_item where order_id  = #{orderId}
</select>

会员服务的接口

    /**
     * 获取会员详细信息
     * @param userId
     * @return
     */
    public UserInfoRTO selectUserInfo(Integer userId);


	@Override
    public UserInfoRTO selectUserInfo(Integer userId) {
        UserInfoRTO userInfo = null;
        log.info("请求会员接口开始, 入参 {}", JSON.toJSONString(userId));
        HttpHeaders header = new HttpHeaders();
        header.set(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
        HttpEntity<Object> entity = new HttpEntity<>(userId, header);
        RemoteResult<UserInfoRTO> remoteResult = restTemplate.exchange(memberAddress+"/member/service/user/"+userId, HttpMethod.POST, entity, new ParameterizedTypeReference<RemoteResult<UserInfoRTO>>() {
        }).getBody();
        if (!remoteResult.isSuccess()){
            return new UserInfoRTO();
        }else{
            userInfo = remoteResult.getBody();
            log.info("请求会员接口结束, 出参 {}", JSON.toJSONString(userId));
            return userInfo;
        }
    }