gov.h

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the Apache 2.0 License.
#pragma once
 
#include "ccf/ds/json.h"
#include "ccf/kv/map.h"
#include "ccf/service/tables/proposals.h"
 
namespace ccf::jsgov
{
  using Ballots = std::unordered_map<ccf::MemberId, std::string>;
  using Votes = std::unordered_map<ccf::MemberId, bool>;
 
  struct Failure
  {
    std::string reason;
    std::optional<std::string> trace;
    bool operator==(const Failure& rhs) const
    {
      return reason == rhs.reason && trace == rhs.trace;
    }
    bool operator!=(const Failure& rhs) const
    {
      return !(*this == rhs);
    }
  };
  DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS(Failure);
  DECLARE_JSON_REQUIRED_FIELDS(Failure, reason);
  DECLARE_JSON_OPTIONAL_FIELDS(Failure, trace);
  using VoteFailures = std::unordered_map<ccf::MemberId, Failure>;
 
  struct ProposalInfo
  {
    ccf::MemberId proposer_id;
    ccf::ProposalState state = ccf::ProposalState::OPEN;
    Ballots ballots;
    std::optional<Votes> final_votes = std::nullopt;
    std::optional<VoteFailures> vote_failures = std::nullopt;
    std::optional<Failure> failure = std::nullopt;
  };
  DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS(ProposalInfo);
  DECLARE_JSON_REQUIRED_FIELDS(ProposalInfo, proposer_id, state, ballots);
  DECLARE_JSON_OPTIONAL_FIELDS(
    ProposalInfo, final_votes, vote_failures, failure);
 
  struct ProposalInfoSummary
  {
    ccf::ProposalId proposal_id;
    ccf::MemberId proposer_id;
    ccf::ProposalState state;
    size_t ballot_count;
    std::optional<Votes> votes = std::nullopt;
    std::optional<VoteFailures> vote_failures = std::nullopt;
    std::optional<Failure> failure = std::nullopt;
  };
  DECLARE_JSON_TYPE_WITH_OPTIONAL_FIELDS(ProposalInfoSummary);
  DECLARE_JSON_REQUIRED_FIELDS(
    ProposalInfoSummary, proposal_id, proposer_id, state, ballot_count);
  DECLARE_JSON_OPTIONAL_FIELDS(
    ProposalInfoSummary, votes, vote_failures, failure);
 
  using ProposalMap =
    ccf::kv::RawCopySerialisedMap<ccf::ProposalId, std::vector<uint8_t>>;
  using ProposalInfoMap = ServiceMap<ccf::ProposalId, ProposalInfo>;
 
  namespace Tables
  {
    static constexpr auto PROPOSALS = "public:ccf.gov.proposals";
    static constexpr auto PROPOSALS_INFO = "public:ccf.gov.proposals_info";
  }
 
  struct Action
  {
    std::string name;
    nlohmann::json args;
  };
  DECLARE_JSON_TYPE(Action);
  DECLARE_JSON_REQUIRED_FIELDS(Action, name, args);
 
  struct Proposal
  {
    std::vector<Action> actions;
  };
  DECLARE_JSON_TYPE(Proposal);
  DECLARE_JSON_REQUIRED_FIELDS(Proposal, actions);
 
  struct Ballot
  {
    std::string ballot;
  };
  DECLARE_JSON_TYPE(Ballot);
  DECLARE_JSON_REQUIRED_FIELDS(Ballot, ballot);
}
 
FMT_BEGIN_NAMESPACE
template <>
struct formatter<std::optional<ccf::jsgov::Failure>>
{
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx)
  {
    return ctx.begin();
  }
 
  template <typename FormatContext>
  auto format(
    const std::optional<ccf::jsgov::Failure>& f, FormatContext& ctx) const
  {
    if (f.has_value())
    {
      return format_to(
        ctx.out(), "{}\nTrace: {}", f->reason, f->trace.value_or("N/A"));
    }
    return format_to(ctx.out(), "N/A");
  }
};
FMT_END_NAMESPACE