How to use

QueryHandler

in

org.axonframework.queryhandling

  @QueryHandler
  public UserSummaryProjection handle(FindUserQuery query) {
    System.out.println("User created query handled");
    return null;
  }
}

@QueryHandler
public List<RoomSummary> on(AllRoomsQuery query){
  return roomSummaryRepository.findAll();
}

@QueryHandler
public List<String> on(RoomParticipantsQuery query) {
  return repository.findRoomParticipantsByRoomId(query.getRoomId())
           .stream()
           .map(RoomParticipant::getParticipant).sorted().collect(toList());
}

@QueryHandler
public List<OrderBookView> find(OrderBooksByCompanyIdQuery query) {
  String companyId = query.getCompanyId().getIdentifier();
  return Optional.ofNullable(orderBookRepository.findByCompanyIdentifier(companyId))
          .map(this::eagerInit)
          .orElseGet(() -> {
            logger.warn("Tried to retrieve a OrderBook query model with a non existent company id [{}]",
                  companyId);
            return Collections.emptyList();
          });
}

@QueryHandler
public UserView find(UserByIdQuery query) {
  String userId = query.getUserId().getIdentifier();
  return Optional.ofNullable(userRepository.findByIdentifier(userId))
          .orElseGet(() -> {
            logger.warn("Tried to retrieve a User query model with a non existent user id [{}]",
                  userId);
            return null;
          });
}

  @QueryHandler
  public List<TransactionView> find(TransactionsByPortfolioIdQuery query) {
    String portfolioId = query.getPortfolioId().getIdentifier();
    return Optional.ofNullable(transactionViewRepository.findByPortfolioId(portfolioId))
            .orElseGet(() -> {
              logger.warn(
                  "Tried to retrieve a Transaction query model with a non existent portfolio id [{}]",
                  portfolioId
              );
              return Collections.emptyList();
            });
  }
}

@QueryHandler
public CompanyView find(CompanyByIdQuery query) {
  String companyId = query.getCompanyId().getIdentifier();
  //noinspection ConstantConditions
  return Optional.ofNullable(companyRepository.getOne(companyId))
          .orElseGet(() -> {
            logger.warn("Tried to retrieve a Company query model with a non existent company id [{}]",
                  companyId);
            return null;
          });
}

  @QueryHandler
  public List<TradeExecutedView> find(ExecutedTradesByOrderBookIdQuery query) {
    String orderBookId = query.getOrderBookId().getIdentifier();
    return Optional.ofNullable(tradeExecutedRepository.findByOrderBookId(orderBookId))
            .orElseGet(() -> {
              logger.warn(
                  "Tried to retrieve a Executed Trades query model with a non existent order book id [{}]",
                  orderBookId
              );
              return Collections.emptyList();
            });
  }
}

@QueryHandler
public PortfolioView find(PortfolioByIdQuery query) {
  String portfolioId = query.getPortfolioId().getIdentifier();
  //noinspection ConstantConditions
  return Optional.ofNullable(portfolioViewRepository.getOne(portfolioId))
          .orElseGet(() -> {
            logger.warn("Tried to retrieve a Portfolio query model with a non existent portfolio id [{}]",
                  portfolioId);
            return null;
          });
}

  @QueryHandler
  public PortfolioView find(PortfolioByUserIdQuery query) {
    String userId = query.getUserId().getIdentifier();
    return Optional.ofNullable(portfolioViewRepository.findByUserId(userId))
            .orElseGet(() -> {
              logger.warn("Tried to retrieve a Portfolio query model with a non existent user id [{}]",
                    userId);
              return null;
            });
  }
}

@QueryHandler
public TransactionView find(TransactionByIdQuery query) {
  String transactionId = query.getTransactionId().getIdentifier();
  //noinspection ConstantConditions
  return Optional.ofNullable(transactionViewRepository.getOne(transactionId))
          .orElseGet(() -> {
            logger.warn(
                "Tried to retrieve a Transaction query model with a non existent transaction id [{}]",
                transactionId
            );
            return null;
          });
}

@QueryHandler
public OrderBookView find(OrderBookByIdQuery query) {
  String orderBookId = query.getOrderBookId().getIdentifier();
  //noinspection ConstantConditions
  return Optional.ofNullable(orderBookRepository.getOne(orderBookId))
          .map(this::eagerInit)
          .orElseGet(() -> {
            logger.warn(
                "Tried to retrieve a OrderBook query model with a non existent order book id [{}]",
                orderBookId
            );
            return null;
          });
}

@QueryHandler
public CountCardSummariesResponse handle(CountCardSummariesQuery query) {
  log.trace("handling {}", query);
  TypedQuery<Long> jpaQuery = entityManager.createNamedQuery("CardSummary.count", Long.class);
  jpaQuery.setParameter("idStartsWith", query.getFilter().getIdStartsWith());
  return log.exit(new CountCardSummariesResponse(jpaQuery.getSingleResult().intValue(), Instant.now().toEpochMilli()));
}

@QueryHandler
public List<ChatMessage> on(RoomMessagesQuery query) {
  return repository.findAllByRoomIdOrderByTimestamp(query.getRoomId());
}

@QueryHandler
public List<CardSummary> handle(FetchCardSummariesQuery query) {
  log.trace("handling {}", query);
  TypedQuery<CardSummary> jpaQuery = entityManager.createNamedQuery("CardSummary.fetch", CardSummary.class);
  jpaQuery.setParameter("idStartsWith", query.getFilter().getIdStartsWith());
  jpaQuery.setFirstResult(query.getOffset());
  jpaQuery.setMaxResults(query.getLimit());
  return log.exit(jpaQuery.getResultList());
}

  @QueryHandler
  public List<UserView> findAll(FindAllUsersQuery query) {
    return userRepository.findAll(PageRequest.of(query.getPageOffset(), query.getPageSize(), Sort.by(asc("name"))))
               .getContent();
  }
}

  @QueryHandler
  public List<CompanyView> find(FindAllCompaniesQuery query) {
    return companyRepository.findAll(
        PageRequest.of(query.getPageOffset(), query.getPageSize(), Sort.by(asc("name")))
    ).getContent();
  }
}