Envelopes.hpp

Go to the documentation of this file.

#pragma once
 
#include <Envelope.hpp>
#include <cstdint>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace lacte::bus {

inline constexpr auto K_PARAM_AERATION = "aeration";
 
// ---------------------------------------------------------------------------
// Вспомогательные функции кодирования на проводе, общие для нескольких
// типов сообщений ниже.
// ---------------------------------------------------------------------------
 
inline auto bool_to_string(const bool value) -> std::string {
  return value ? "true" : "false";
}
 
inline auto string_to_bool(const std::string& value) -> bool {
  return value == "true" || value == "1" || value == "online" ||
         value == "enabled";
}

inline auto string_to_int(const std::string& value) -> int {
  try {
    return std::stoi(value);
  } catch (const std::exception&) {
    throw std::invalid_argument("lacte bus integer field is invalid: " + value);
  }
}

struct BoardSnapshot {
  bool board_online{
      false};       
  int aeration{0};  
  std::string app_version;     
  std::string fw_version;      
  std::string milk_system_sn;  
  std::string expiry_date;     
  std::optional<std::uint64_t>
      remaining_percent;  
  std::optional<std::uint16_t>
      error_flags;  
  std::string system_state;
};

struct RfidData {
  bool present{false};
  std::string rfid_number;     
  std::string lacte_id;        
  std::string lacte_sn;        
  std::string mcu_uid;         
  std::string machine_sn;      
  std::string product_volume;  
  std::string prod_date;       
  std::string shelf_life;      
  std::string usage_time;      
  std::string activation_time;  
  std::string milk_counter;     
  std::string time_counter;     
};
 
namespace detail {
 
inline void encode_board_snapshot(insitech::bus::Envelope& envelope,
                                  const BoardSnapshot& snapshot) {
  envelope.m_headers["online"] = bool_to_string(snapshot.board_online);
  envelope.m_headers["aeration"] = std::to_string(snapshot.aeration);
  envelope.m_headers["app_version"] = snapshot.app_version;
  envelope.m_headers["fw_version"] = snapshot.fw_version;
  envelope.m_headers["milk_system_sn"] = snapshot.milk_system_sn;
  envelope.m_headers["expiry_date"] = snapshot.expiry_date;
  if (snapshot.remaining_percent) {
    envelope.m_headers["remaining_percent"] =
        std::to_string(*snapshot.remaining_percent);
  }
  if (snapshot.error_flags) {
    envelope.m_headers["error_flags"] = std::to_string(*snapshot.error_flags);
  }
  if (!snapshot.system_state.empty()) {
    envelope.m_headers["system_state"] = snapshot.system_state;
  }
}
 
inline auto decode_board_snapshot(const insitech::bus::Envelope& envelope)
    -> BoardSnapshot {
  BoardSnapshot snapshot{};
  if (const auto found = envelope.m_headers.find("online");
      found != envelope.m_headers.end()) {
    snapshot.board_online = string_to_bool(found->second);
  }
  if (const auto found = envelope.m_headers.find("aeration");
      found != envelope.m_headers.end()) {
    snapshot.aeration = string_to_int(found->second);
  }
  if (const auto found = envelope.m_headers.find("app_version");
      found != envelope.m_headers.end()) {
    snapshot.app_version = found->second;
  }
  if (const auto found = envelope.m_headers.find("fw_version");
      found != envelope.m_headers.end()) {
    snapshot.fw_version = found->second;
  }
  if (const auto found = envelope.m_headers.find("milk_system_sn");
      found != envelope.m_headers.end()) {
    snapshot.milk_system_sn = found->second;
  }
  if (const auto found = envelope.m_headers.find("expiry_date");
      found != envelope.m_headers.end()) {
    snapshot.expiry_date = found->second;
  }
  if (const auto found = envelope.m_headers.find("remaining_percent");
      found != envelope.m_headers.end()) {
    snapshot.remaining_percent =
        static_cast<std::uint64_t>(string_to_int(found->second));
  }
  if (const auto found = envelope.m_headers.find("error_flags");
      found != envelope.m_headers.end()) {
    snapshot.error_flags =
        static_cast<std::uint16_t>(string_to_int(found->second));
  }
  if (const auto found = envelope.m_headers.find("system_state");
      found != envelope.m_headers.end()) {
    snapshot.system_state = found->second;
  }
  return snapshot;
}
 
inline void encode_rfid_data(insitech::bus::Envelope& envelope,
                             const RfidData& data) {
  envelope.m_headers["present"] = bool_to_string(data.present);
  if (!data.present) {
    return;  // все остальные поля бессмысленны/пусты - см. doc-комментарий
             // самой RfidData
  }
  envelope.m_headers["rfid_number"] = data.rfid_number;
  envelope.m_headers["lacte_id"] = data.lacte_id;
  envelope.m_headers["lacte_sn"] = data.lacte_sn;
  envelope.m_headers["mcu_uid"] = data.mcu_uid;
  envelope.m_headers["machine_sn"] = data.machine_sn;
  envelope.m_headers["product_volume"] = data.product_volume;
  envelope.m_headers["prod_date"] = data.prod_date;
  envelope.m_headers["shelf_life"] = data.shelf_life;
  envelope.m_headers["usage_time"] = data.usage_time;
  envelope.m_headers["activation_time"] = data.activation_time;
  envelope.m_headers["milk_counter"] = data.milk_counter;
  envelope.m_headers["time_counter"] = data.time_counter;
}
 
inline auto decode_rfid_data(const insitech::bus::Envelope& envelope)
    -> RfidData {
  RfidData data{};
  if (const auto found = envelope.m_headers.find("present");
      found != envelope.m_headers.end()) {
    data.present = string_to_bool(found->second);
  }
  if (!data.present) {
    return data;
  }
  auto field = [&](const char* key, std::string& out) -> void {
    if (const auto found = envelope.m_headers.find(key);
        found != envelope.m_headers.end()) {
      out = found->second;
    }
  };
  field("rfid_number", data.rfid_number);
  field("lacte_id", data.lacte_id);
  field("lacte_sn", data.lacte_sn);
  field("mcu_uid", data.mcu_uid);
  field("machine_sn", data.machine_sn);
  field("product_volume", data.product_volume);
  field("prod_date", data.prod_date);
  field("shelf_life", data.shelf_life);
  field("usage_time", data.usage_time);
  field("activation_time", data.activation_time);
  field("milk_counter", data.milk_counter);
  field("time_counter", data.time_counter);
  return data;
}
 
}  // namespace detail
 
// ---------------------------------------------------------------------------
// Типы сообщений. Тип, который реально используется в Publish()/Subscribe()/
// как запрос Serve<Req,...>/Request<Req,...>, несёт K_TOPIC; тип,
// используемый только как ответ, - нет (см. doc-комментарий файла выше).
// ---------------------------------------------------------------------------

struct HealthRequest {
  static constexpr auto K_TOPIC = "health";
  static constexpr auto
      kTopic =  // NOLINT(readability-identifier-naming): баг protolib —
                // serve<Req,Reply>() читает Req::kTopic,
                // request<Req,Reply>()/request_to() читает Req::K_TOPIC для
                // того же типа Req; оба имени должны существовать
                // одновременно.
      K_TOPIC;
  [[nodiscard]] static auto build() -> std::vector<uint8_t> { return {}; }
  static auto parse(const std::vector<uint8_t>& /*unused*/) -> HealthRequest {
    return {};
  }
};

struct StatusReply {
  bool ok{false};
  std::string error;
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    envelope.m_headers["status"] = ok ? "ok" : "error";
    if (!error.empty()) {
      envelope.m_headers["error"] = error;
    }
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> StatusReply {
    const auto [m_headers, m_payload] = insitech::bus::decode_envelope(bytes);
    StatusReply reply;
    if (const auto found = m_headers.find("status"); found != m_headers.end()) {
      reply.ok = found->second == "ok";
    }
    if (const auto found = m_headers.find("error"); found != m_headers.end()) {
      reply.error = found->second;
    }
    return reply;
  }
};

struct ParamGetRequest {
  static constexpr auto K_TOPIC = "param.get";
  static constexpr auto
      kTopic =  // NOLINT(readability-identifier-naming): баг protolib —
                // serve<Req,Reply>() читает Req::kTopic,
                // request<Req,Reply>()/request_to() читает Req::K_TOPIC для
                // того же типа Req; оба имени должны существовать
                // одновременно.
      K_TOPIC;
  std::string param;
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    envelope.m_headers["param"] = param;
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> ParamGetRequest {
    const auto [m_headers, m_payload] = insitech::bus::decode_envelope(bytes);
    ParamGetRequest request;
    if (const auto found = m_headers.find("param"); found != m_headers.end()) {
      request.param = found->second;
    }
    return request;
  }
};

struct ParamGetReply {
  bool ok{false};
  std::string error;
  std::string param;
  int value{0};
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    envelope.m_headers["status"] = ok ? "ok" : "error";
    if (!error.empty()) {
      envelope.m_headers["error"] = error;
    }
    if (ok) {
      envelope.m_headers["param"] = param;
      envelope.m_headers["value"] = std::to_string(value);
    }
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> ParamGetReply {
    const auto [m_headers, m_payload] = insitech::bus::decode_envelope(bytes);
    ParamGetReply reply;
    if (const auto found = m_headers.find("status"); found != m_headers.end()) {
      reply.ok = found->second == "ok";
    }
    if (const auto found = m_headers.find("error"); found != m_headers.end()) {
      reply.error = found->second;
    }
    if (const auto found = m_headers.find("param"); found != m_headers.end()) {
      reply.param = found->second;
    }
    if (const auto found = m_headers.find("value"); found != m_headers.end()) {
      reply.value = string_to_int(found->second);
    }
    return reply;
  }
};

struct ParamSetRequest {
  static constexpr auto K_TOPIC = "param.set";
  static constexpr auto
      kTopic =  // NOLINT(readability-identifier-naming): баг protolib —
                // serve<Req,Reply>() читает Req::kTopic,
                // request<Req,Reply>()/request_to() читает Req::K_TOPIC для
                // того же типа Req; оба имени должны существовать
                // одновременно.
      K_TOPIC;
  std::string param;
  int value{0};
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    envelope.m_headers["param"] = param;
    envelope.m_headers["value"] = std::to_string(value);
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> ParamSetRequest {
    const auto envelope = insitech::bus::decode_envelope(bytes);
    ParamSetRequest request;
    if (const auto found = envelope.m_headers.find("param");
        found != envelope.m_headers.end()) {
      request.param = found->second;
    }
    if (const auto found = envelope.m_headers.find("value");
        found != envelope.m_headers.end()) {
      request.value = string_to_int(found->second);
    }
    return request;
  }
};

struct SnapshotRequest {
  static constexpr auto K_TOPIC = "snapshot.get";
  static constexpr auto
      kTopic =  // NOLINT(readability-identifier-naming): баг protolib —
                // serve<Req,Reply>() читает Req::kTopic,
                // request<Req,Reply>()/request_to() читает Req::K_TOPIC для
                // того же типа Req; оба имени должны существовать
                // одновременно.
      K_TOPIC;
  [[nodiscard]] static auto build() -> std::vector<uint8_t> { return {}; }
  static auto parse(const std::vector<uint8_t>& /*unused*/) -> SnapshotRequest {
    return {};
  }
};

struct SnapshotReply {
  bool ok{false};
  std::string error;
  BoardSnapshot snapshot{};
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    envelope.m_headers["status"] = ok ? "ok" : "error";
    if (!error.empty()) {
      envelope.m_headers["error"] = error;
    }
    detail::encode_board_snapshot(envelope, snapshot);
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> SnapshotReply {
    const auto envelope = insitech::bus::decode_envelope(bytes);
    SnapshotReply reply;
    if (const auto found = envelope.m_headers.find("status");
        found != envelope.m_headers.end()) {
      reply.ok = found->second == "ok";
    }
    if (const auto found = envelope.m_headers.find("error");
        found != envelope.m_headers.end()) {
      reply.error = found->second;
    }
    reply.snapshot = detail::decode_board_snapshot(envelope);
    return reply;
  }
};

struct RfidDataRequest {
  static constexpr auto K_TOPIC = "rfid.get";
  static constexpr auto
      kTopic =  // NOLINT(readability-identifier-naming): баг protolib —
                // serve<Req,Reply>() читает Req::kTopic,
                // request<Req,Reply>()/request_to() читает Req::K_TOPIC для
                // того же типа Req; оба имени должны существовать
                // одновременно.
      K_TOPIC;
  [[nodiscard]] static auto build() -> std::vector<uint8_t> { return {}; }
  static auto parse(const std::vector<uint8_t>& /*unused*/) -> RfidDataRequest {
    return {};
  }
};

struct RfidDataReply {
  bool ok{false};
  std::string error;
  RfidData data{};
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    envelope.m_headers["status"] = ok ? "ok" : "error";
    if (!error.empty()) {
      envelope.m_headers["error"] = error;
    }
    detail::encode_rfid_data(envelope, data);
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> RfidDataReply {
    const auto envelope = insitech::bus::decode_envelope(bytes);
    RfidDataReply reply;
    if (const auto found = envelope.m_headers.find("status");
        found != envelope.m_headers.end()) {
      reply.ok = found->second == "ok";
    }
    if (const auto found = envelope.m_headers.find("error");
        found != envelope.m_headers.end()) {
      reply.error = found->second;
    }
    reply.data = detail::decode_rfid_data(envelope);
    return reply;
  }
};

struct TestBoardOnlineRequest {
  static constexpr auto K_TOPIC = "test.board.online.set";
  static constexpr auto
      kTopic =  // NOLINT(readability-identifier-naming): баг protolib —
                // serve<Req,Reply>() читает Req::kTopic,
                // request<Req,Reply>()/request_to() читает Req::K_TOPIC для
                // того же типа Req; оба имени должны существовать
                // одновременно.
      K_TOPIC;
  bool online{false};
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    envelope.m_headers["online"] = bool_to_string(online);
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes)
      -> TestBoardOnlineRequest {
    const auto [m_headers, m_payload] = insitech::bus::decode_envelope(bytes);
    TestBoardOnlineRequest request;
    if (const auto found = m_headers.find("online"); found != m_headers.end()) {
      request.online = string_to_bool(found->second);
    }
    return request;
  }
};

struct UiCommand {
  static constexpr auto K_TOPIC = "command";
  bool enable{false};
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    const std::string command = enable ? "enable" : "disable";
    return {command.begin(), command.end()};
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> UiCommand {
    const std::string command(bytes.begin(), bytes.end());
    return {command == "enable"};
  }
};

struct BoardSnapshotEvent {
  static constexpr auto K_TOPIC = "snapshot";
  BoardSnapshot snapshot{};
 
  [[nodiscard]] auto build() const -> std::vector<uint8_t> {
    insitech::bus::Envelope envelope;
    detail::encode_board_snapshot(envelope, snapshot);
    return insitech::bus::encode_envelope(envelope);
  }
  static auto parse(const std::vector<uint8_t>& bytes) -> BoardSnapshotEvent {
    return {
        detail::decode_board_snapshot(insitech::bus::decode_envelope(bytes))};
  }
};
 
}  // namespace lacte::bus