InputMessageContent.hpp

Go to the documentation of this file.

#pragma once
#include <tgbotxx/objects/LabeledPrice.hpp>
#include <tgbotxx/objects/MessageEntity.hpp>
#include <tgbotxx/objects/Object.hpp>
 
namespace tgbotxx {
  struct InputMessageContent {
    InputMessageContent() = default;
    explicit InputMessageContent(const nl::json& json) {
      InputMessageContent::fromJson(json);
    }
    virtual ~InputMessageContent() = default;
 
    std::string type;
 
 
    [[nodiscard]] virtual nl::json toJson() const {
      nl::json json = nl::json::object();
      OBJECT_SERIALIZE_FIELD(json, "type", type);
      return json;
    }
 
    virtual void fromJson(const nl::json& json) {
      OBJECT_DESERIALIZE_FIELD(json, "type", type, "", false);
    }
  };
 
 
  struct InputTextMessageContent : InputMessageContent {
    InputTextMessageContent() {
      type = "text";
    }
    explicit InputTextMessageContent(const nl::json& json) {
      InputTextMessageContent::fromJson(json);
    }
 
    std::string messageText;
 
    std::string parseMode;
 
    std::vector<Ptr<MessageEntity>> entities;
 
    bool disableWebPagePreview{};
 
    nl::json toJson() const override {
      nl::json json = InputMessageContent::toJson();
      OBJECT_SERIALIZE_FIELD(json, "message_text", messageText);
      OBJECT_SERIALIZE_FIELD(json, "parse_mode", parseMode);
      OBJECT_SERIALIZE_FIELD_PTR_ARRAY(json, "entities", entities);
      OBJECT_SERIALIZE_FIELD(json, "disable_web_page_preview", disableWebPagePreview);
      return json;
    }
 
    void fromJson(const nl::json& json) override {
      InputMessageContent::fromJson(json);
      OBJECT_DESERIALIZE_FIELD(json, "message_text", messageText, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "parse_mode", parseMode, "", true);
      OBJECT_DESERIALIZE_FIELD_PTR_ARRAY(json, "entities", entities, true);
      OBJECT_DESERIALIZE_FIELD(json, "disable_web_page_preview", disableWebPagePreview, false, true);
    }
  };
 
 
  struct InputLocationMessageContent : InputMessageContent {
    InputLocationMessageContent() {
      type = "location";
    }
    explicit InputLocationMessageContent(const nl::json& json) {
      InputLocationMessageContent::fromJson(json);
    }
 
    float latitude{};
 
    float longitude{};
 
    float horizontalAccuracy{};
 
    std::int32_t heading{};
 
    std::int32_t proximityAlertRadius{};
 
 
    nl::json toJson() const override {
      nl::json json = InputMessageContent::toJson();
      OBJECT_SERIALIZE_FIELD(json, "latitude", latitude);
      OBJECT_SERIALIZE_FIELD(json, "longitude", longitude);
      OBJECT_SERIALIZE_FIELD(json, "horizontal_accuracy", horizontalAccuracy);
      OBJECT_SERIALIZE_FIELD(json, "heading", heading);
      OBJECT_SERIALIZE_FIELD(json, "proximity_alert_radius", proximityAlertRadius);
      return json;
    }
 
    void fromJson(const nl::json& json) override {
      InputMessageContent::fromJson(json);
      OBJECT_DESERIALIZE_FIELD(json, "latitude", latitude, 0.0f, false);
      OBJECT_DESERIALIZE_FIELD(json, "longitude", longitude, 0.0f, false);
      OBJECT_DESERIALIZE_FIELD(json, "horizontal_accuracy", horizontalAccuracy, 0.0f, true);
      OBJECT_DESERIALIZE_FIELD(json, "heading", heading, 0, true);
      OBJECT_DESERIALIZE_FIELD(json, "proximity_alert_radius", proximityAlertRadius, 0, true);
    }
  };
 
  struct InputVenueMessageContent : InputMessageContent {
    InputVenueMessageContent() {
      type = "venue";
    }
    explicit InputVenueMessageContent(const nl::json& json) {
      InputVenueMessageContent::fromJson(json);
    }
 
    float latitude{};
 
    float longitude{};
 
    std::string title;
 
    std::string address;
 
    std::string foursquareId;
 
    std::string foursquareType;
 
    std::string googlePlaceId;
 
    std::string googlePlaceType;
 
    nl::json toJson() const override {
      nl::json json = InputMessageContent::toJson();
      OBJECT_SERIALIZE_FIELD(json, "latitude", latitude);
      OBJECT_SERIALIZE_FIELD(json, "longitude", longitude);
      OBJECT_SERIALIZE_FIELD(json, "title", title);
      OBJECT_SERIALIZE_FIELD(json, "address", address);
      OBJECT_SERIALIZE_FIELD(json, "foursquare_id", foursquareId);
      OBJECT_SERIALIZE_FIELD(json, "foursquare_type", foursquareType);
      OBJECT_SERIALIZE_FIELD(json, "google_place_id", googlePlaceId);
      OBJECT_SERIALIZE_FIELD(json, "google_place_type", googlePlaceType);
      return json;
    }
 
    void fromJson(const nl::json& json) override {
      InputMessageContent::fromJson(json);
      OBJECT_DESERIALIZE_FIELD(json, "latitude", latitude, 0.0f, false);
      OBJECT_DESERIALIZE_FIELD(json, "longitude", longitude, 0.0f, false);
      OBJECT_DESERIALIZE_FIELD(json, "title", title, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "address", address, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "foursquare_id", foursquareId, "", true);
      OBJECT_DESERIALIZE_FIELD(json, "foursquare_type", foursquareType, "", true);
      OBJECT_DESERIALIZE_FIELD(json, "google_place_id", googlePlaceId, "", true);
      OBJECT_DESERIALIZE_FIELD(json, "google_place_type", googlePlaceType, "", true);
    }
  };
 
  struct InputContactMessageContent : InputMessageContent {
    InputContactMessageContent() {
      type = "contact";
    }
    explicit InputContactMessageContent(const nl::json& json) {
      InputContactMessageContent::fromJson(json);
    }
 
    std::string phoneNumber;
 
    std::string firstName;
 
    std::string lastName;
 
    std::string vcard;
 
    nl::json toJson() const override {
      nl::json json = InputMessageContent::toJson();
      OBJECT_SERIALIZE_FIELD(json, "phone_number", phoneNumber);
      OBJECT_SERIALIZE_FIELD(json, "first_name", firstName);
      OBJECT_SERIALIZE_FIELD(json, "last_name", lastName);
      OBJECT_SERIALIZE_FIELD(json, "vcard", vcard);
      return json;
    }
 
    void fromJson(const nl::json& json) override {
      InputMessageContent::fromJson(json);
      OBJECT_DESERIALIZE_FIELD(json, "phone_number", phoneNumber, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "first_name", firstName, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "last_name", lastName, "", true);
      OBJECT_DESERIALIZE_FIELD(json, "vcard", vcard, "", true);
    }
  };
 
  struct InputInvoiceMessageContent : InputMessageContent {
    InputInvoiceMessageContent() {
      type = "invoice";
    }
    explicit InputInvoiceMessageContent(const nl::json& json) {
      InputInvoiceMessageContent::fromJson(json);
    }
 
    std::string title;
 
    std::string description;
 
    std::string payload;
 
    std::string providerToken;
 
    std::string currency;
 
    std::vector<Ptr<LabeledPrice>> prices;
 
    std::int32_t maxTipAmount{};
 
    std::vector<std::int32_t> suggestedTipAmounts;
 
    std::string providerData;
 
    std::string photoUrl;
 
    std::int64_t photoSize{};
 
    std::int32_t photoWidth{};
 
    std::int32_t photoHeight{};
 
    bool needName{};
 
    bool needPhoneNumber{};
 
    bool needEmail{};
 
    bool needShippingAddress{};
 
    bool sendPhoneNumberToProvider{};
 
    bool sendEmailToProvider{};
 
    bool isFlexible{};
 
    nl::json toJson() const override {
      nl::json json = InputMessageContent::toJson();
      OBJECT_SERIALIZE_FIELD(json, "title", title);
      OBJECT_SERIALIZE_FIELD(json, "description", description);
      OBJECT_SERIALIZE_FIELD(json, "payload", payload);
      OBJECT_SERIALIZE_FIELD(json, "provider_token", providerToken);
      OBJECT_SERIALIZE_FIELD(json, "currency", currency);
      OBJECT_SERIALIZE_FIELD_PTR_ARRAY(json, "prices", prices);
      OBJECT_SERIALIZE_FIELD(json, "max_tip_amount", maxTipAmount);
      OBJECT_SERIALIZE_FIELD(json, "suggested_tip_amounts", suggestedTipAmounts);
      OBJECT_SERIALIZE_FIELD(json, "provider_data", providerData);
      OBJECT_SERIALIZE_FIELD(json, "photo_url", photoUrl);
      OBJECT_SERIALIZE_FIELD(json, "photo_size", photoSize);
      OBJECT_SERIALIZE_FIELD(json, "photo_width", photoWidth);
      OBJECT_SERIALIZE_FIELD(json, "photo_height", photoHeight);
      OBJECT_SERIALIZE_FIELD(json, "need_name", needName);
      OBJECT_SERIALIZE_FIELD(json, "need_phone_number", needPhoneNumber);
      OBJECT_SERIALIZE_FIELD(json, "need_email", needEmail);
      OBJECT_SERIALIZE_FIELD(json, "need_shipping_address", needShippingAddress);
      OBJECT_SERIALIZE_FIELD(json, "send_phone_number_to_provider", sendPhoneNumberToProvider);
      OBJECT_SERIALIZE_FIELD(json, "send_email_to_provider", sendEmailToProvider);
      OBJECT_SERIALIZE_FIELD(json, "is_flexible", isFlexible);
      return json;
    }
 
    void fromJson(const nl::json& json) override {
      InputMessageContent::fromJson(json);
      OBJECT_DESERIALIZE_FIELD(json, "title", title, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "description", description, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "payload", payload, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "provider_token", providerToken, "", false);
      OBJECT_DESERIALIZE_FIELD(json, "currency", currency, "", false);
      OBJECT_DESERIALIZE_FIELD_PTR_ARRAY(json, "prices", prices, false);
      OBJECT_DESERIALIZE_FIELD(json, "max_tip_amount", maxTipAmount, 0, true);
      OBJECT_DESERIALIZE_FIELD(json, "suggested_tip_amounts", suggestedTipAmounts, std::vector<std::int32_t>(), true);
      OBJECT_DESERIALIZE_FIELD(json, "provider_data", providerData, "", true);
      OBJECT_DESERIALIZE_FIELD(json, "photo_url", photoUrl, "", true);
      OBJECT_DESERIALIZE_FIELD(json, "photo_size", photoSize, 0, true);
      OBJECT_DESERIALIZE_FIELD(json, "photo_width", photoWidth, 0, true);
      OBJECT_DESERIALIZE_FIELD(json, "photo_height", photoHeight, 0, true);
      OBJECT_DESERIALIZE_FIELD(json, "need_name", needName, false, true);
      OBJECT_DESERIALIZE_FIELD(json, "need_phone_number", needPhoneNumber, false, true);
      OBJECT_DESERIALIZE_FIELD(json, "need_email", needEmail, false, true);
      OBJECT_DESERIALIZE_FIELD(json, "need_shipping_address", needShippingAddress, false, true);
      OBJECT_DESERIALIZE_FIELD(json, "send_phone_number_to_provider", sendPhoneNumberToProvider, false, true);
      OBJECT_DESERIALIZE_FIELD(json, "send_email_to_provider", sendEmailToProvider, false, true);
      OBJECT_DESERIALIZE_FIELD(json, "is_flexible", isFlexible, false, true);
    }
  };
}