DialoguePayment.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ResourceAccount.h"
#include "common/StateAccess.h"
#include "common/Value.h"
#include "transaction/Transaction.h"
 
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <vector>
 
namespace eve::dialogue {
 
struct EVENGINE_API_ORCHESTRATION PaymentSpec {
    std::optional<std::int64_t> money;
    std::optional<std::int64_t> reputation;
 
    [[nodiscard]] bool empty() const noexcept { return !money && !reputation; }
    [[nodiscard]] eve::Result<void> validate() const;
    [[nodiscard]] static eve::Result<PaymentSpec> fromValue(const eve::Value& value);
    [[nodiscard]] eve::Value toValue() const;
};
 
struct DialogueAccountBindings {
    eve::resource::IResourceAccount* money = nullptr;
    eve::resource::IResourceAccount* reputation = nullptr;
    std::string moneyResource = "gold";
    std::string reputationResource = "reputation";
};
 
class DialogueStateMutationParticipant final : public eve::transaction::ITransactionParticipant {
public:
    DialogueStateMutationParticipant(eve::IStateMutation& provider, std::span<const eve::StateMutation> mutations);
 
    DialogueStateMutationParticipant(const DialogueStateMutationParticipant&)            = delete;
    DialogueStateMutationParticipant& operator=(const DialogueStateMutationParticipant&) = delete;
    DialogueStateMutationParticipant(DialogueStateMutationParticipant&&)                 = delete;
    DialogueStateMutationParticipant& operator=(DialogueStateMutationParticipant&&)      = delete;
    ~DialogueStateMutationParticipant() override                                         = default;
 
    [[nodiscard]] std::string_view name() const noexcept override { return "dialogue.state-mutation"; }
    [[nodiscard]] eve::Result<void> prepare(const eve::transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> commit(const eve::transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> rollback(const eve::transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> compensate(const eve::transaction::TransactionContext& context) override;
 
private:
    enum class Phase : std::uint8_t { Idle, Prepared, Committed, RolledBack };
 
    eve::IStateMutation&            provider_;
    std::vector<eve::StateMutation> mutations_;
    Phase                           phase_ = Phase::Idle;
};
 
class EVENGINE_API_ORCHESTRATION DialoguePaymentAdapter final {
public:
    explicit DialoguePaymentAdapter(DialogueAccountBindings bindings = {});
 
    void setBindings(DialogueAccountBindings bindings);
    [[nodiscard]] const DialogueAccountBindings& bindings() const noexcept { return bindings_; }
 
    [[nodiscard]] eve::Result<eve::transaction::TransactionReceipt> execute(
        std::string transactionId, const PaymentSpec& payment,
        std::span<eve::transaction::ITransactionParticipant*> effects) const;
 
    [[nodiscard]] eve::Result<eve::transaction::TransactionReceipt> executeStateMutation(
        std::string transactionId, const PaymentSpec& payment, eve::IStateMutation& provider,
        std::span<const eve::StateMutation> mutations) const;
 
private:
    DialogueAccountBindings bindings_;
};
 
}  // namespace eve::dialogue