query_response_factory.hpp

Go to the documentation of this file.

#ifndef IROHA_QUERY_RESPONSE_FACTORY_HPP
#define IROHA_QUERY_RESPONSE_FACTORY_HPP

#include <memory>

#include <optional>
#include "interfaces/common_objects/account.hpp"
#include "interfaces/common_objects/asset.hpp"
#include "interfaces/common_objects/types.hpp"
#include "interfaces/permissions.hpp"
#include "interfaces/queries/account_detail_record_id.hpp"
#include "interfaces/query_responses/block_query_response.hpp"
#include "interfaces/query_responses/engine_receipt.hpp"
#include "interfaces/query_responses/error_query_response.hpp"
#include "interfaces/query_responses/pending_transactions_page_response.hpp"
#include "interfaces/query_responses/query_response.hpp"

namespace shared_model {
  namespace crypto {
    class Hash;
  }
  namespace interface {
    class Block;
    class Amount;
  }  // namespace interface
}  // namespace shared_model

namespace shared_model {
  namespace interface {

    class QueryResponseFactory {
     public:
      virtual ~QueryResponseFactory() = default;

      virtual std::unique_ptr<QueryResponse> createAccountAssetResponse(
          std::vector<std::tuple<types::AccountIdType,
                                 types::AssetIdType,
                                 shared_model::interface::Amount>> assets,
          size_t total_assets_number,
          std::optional<shared_model::interface::types::AssetIdType>
              next_asset_id,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createAccountDetailResponse(
          types::DetailType account_detail,
          size_t total_number,
          std::optional<std::reference_wrapper<
              const shared_model::interface::AccountDetailRecordId>>
              next_record_id,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createAccountResponse(
          interface::types::AccountIdType account_id,
          interface::types::DomainIdType domain_id,
          interface::types::QuorumType quorum,
          interface::types::JsonType jsonData,
          std::vector<std::string> roles,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createBlockResponse(
          std::unique_ptr<Block> block,
          const crypto::Hash &query_hash) const = 0;

      enum class ErrorQueryType {
        kStatelessFailed,
        kStatefulFailed,
        kNoAccount,
        kNoAccountAssets,
        kNoAccountDetail,
        kNoSignatories,
        kNotSupported,
        kNoAsset,
        kNoRoles
      };
      virtual std::unique_ptr<QueryResponse> createErrorQueryResponse(
          ErrorQueryType error_type,
          ErrorQueryResponse::ErrorMessageType error_msg,
          ErrorQueryResponse::ErrorCodeType error_code,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createSignatoriesResponse(
          std::vector<std::string> signatories,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createTransactionsResponse(
          std::vector<std::unique_ptr<shared_model::interface::Transaction>>
              transactions,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createTransactionsPageResponse(
          std::vector<std::unique_ptr<shared_model::interface::Transaction>>
              transactions,
          std::optional<std::reference_wrapper<const crypto::Hash>>
              next_tx_hash,
          interface::types::TransactionsNumberType all_transactions_size,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse>
      createPendingTransactionsPageResponse(
          std::vector<std::unique_ptr<interface::Transaction>> transactions,
          interface::types::TransactionsNumberType all_transactions_size,
          std::optional<interface::PendingTransactionsPageResponse::BatchInfo>
              next_batch_info,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createAssetResponse(
          types::AssetIdType asset_id,
          types::DomainIdType domain_id,
          types::PrecisionType precision,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createRolesResponse(
          std::vector<types::RoleIdType> roles,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createRolePermissionsResponse(
          RolePermissionSet role_permissions,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createPeersResponse(
          types::PeerList peers, const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<QueryResponse> createEngineReceiptsResponse(
          const std::vector<std::unique_ptr<EngineReceipt>>
              &engine_response_records,
          const crypto::Hash &query_hash) const = 0;

      virtual std::unique_ptr<BlockQueryResponse> createBlockQueryResponse(
          std::shared_ptr<const Block> block) const = 0;

      virtual std::unique_ptr<BlockQueryResponse> createBlockQueryResponse(
          std::string error_message) const = 0;
    };

  }  // namespace interface
}  // namespace shared_model

#endif  // IROHA_QUERY_RESPONSE_FACTORY_HPP