gruubY 0.2.0

data/lib/grubY/types/bound_entities.rb

@@ -0,0 +1,245 @@
+require_relative "base_object"
+
+module GrubY
+  class CallbackQuery < BaseObject
+    fields :id, :from, :message, :inline_message_id, :chat_instance, :data, :game_short_name
+
+    def answer(text = nil, show_alert: false, **opts)
+      call_api("answerCallbackQuery", { callback_query_id: id, text: text, show_alert: show_alert }.merge(opts))
+    end
+
+    def edit_message_text(text, **opts)
+      edit_payload("editMessageText", { text: text }.merge(opts))
+    end
+
+    def edit_message_caption(caption, **opts)
+      edit_payload("editMessageCaption", { caption: caption }.merge(opts))
+    end
+
+    def edit_message_media(media, **opts)
+      edit_payload("editMessageMedia", { media: media }.merge(opts))
+    end
+
+    def edit_message_reply_markup(reply_markup = nil, **opts)
+      edit_payload("editMessageReplyMarkup", { reply_markup: reply_markup }.merge(opts))
+    end
+
+    private
+
+    def edit_payload(method, payload)
+      if inline_message_id.to_s.empty?
+        msg = message || {}
+        call_api(method, payload.merge(chat_id: msg.dig("chat", "id"), message_id: msg["message_id"]))
+      else
+        call_api(method, payload.merge(inline_message_id: inline_message_id))
+      end
+    end
+  end
+
+  class InlineQuery < BaseObject
+    fields :id, :from, :query, :offset, :chat_type, :location
+
+    def answer(results, **opts)
+      call_api("answerInlineQuery", { inline_query_id: id, results: results }.merge(opts))
+    end
+  end
+
+  class PreCheckoutQuery < BaseObject
+    fields :id, :from, :currency, :total_amount, :invoice_payload, :shipping_option_id, :order_info
+
+    def answer(ok:, error_message: nil)
+      call_api("answerPreCheckoutQuery", { pre_checkout_query_id: id, ok: ok, error_message: error_message }.compact)
+    end
+  end
+
+  class ShippingQuery < BaseObject
+    fields :id, :from, :invoice_payload, :shipping_address
+
+    def answer(ok:, shipping_options: nil, error_message: nil)
+      call_api("answerShippingQuery", {
+        shipping_query_id: id,
+        ok: ok,
+        shipping_options: shipping_options,
+        error_message: error_message
+      }.compact)
+    end
+  end
+
+  class ChatJoinRequest < BaseObject
+    fields :chat, :from, :user_chat_id, :date, :bio, :invite_link
+
+    def approve
+      call_api("approveChatJoinRequest", { chat_id: chat_id!, user_id: user_id! })
+    end
+
+    def decline
+      call_api("declineChatJoinRequest", { chat_id: chat_id!, user_id: user_id! })
+    end
+
+    private
+
+    def chat_id!
+      chat.is_a?(Hash) ? chat["id"] : chat&.id
+    end
+
+    def user_id!
+      from.is_a?(Hash) ? from["id"] : from&.id
+    end
+  end
+
+  class Story < BaseObject
+    fields :id, :chat, :date
+
+    def reply_text(text, **opts)
+      chat_id = chat.is_a?(Hash) ? chat["id"] : chat&.id
+      call_api("sendMessage", { chat_id: chat_id, text: text.to_s }.merge(opts))
+    end
+
+    alias reply reply_text
+    alias answer reply_text
+
+    STORY_SENDERS = {
+      animation: "sendAnimation",
+      audio: "sendAudio",
+      cached_media: "sendDocument",
+      media_group: "sendMediaGroup",
+      photo: "sendPhoto",
+      sticker: "sendSticker",
+      video: "sendVideo",
+      video_note: "sendVideoNote",
+      voice: "sendVoice"
+    }.freeze
+
+    STORY_SENDERS.each do |name, method_name|
+      define_method("reply_#{name}") do |payload = nil, **opts|
+        cid = chat.is_a?(Hash) ? chat["id"] : chat&.id
+        params = { chat_id: cid }.merge(opts)
+        params = if name == :media_group
+                   params.merge(media: payload)
+                 elsif name == :cached_media
+                   params.merge(document: payload)
+                 else
+                   params.merge(name => payload)
+                 end
+        call_api(method_name, params)
+      end
+
+      define_method("answer_#{name}") do |payload = nil, **opts|
+        public_send("reply_#{name}", payload, **opts)
+      end
+    end
+
+    def delete
+      call_raw_api("deleteStories", { story_ids: [id] })
+    end
+
+    def edit_media(media, **opts)
+      call_raw_api("editStoryMedia", { story_id: id, media: media }.merge(opts))
+    end
+
+    def edit_caption(caption, **opts)
+      call_raw_api("editStoryCaption", { story_id: id, caption: caption.to_s }.merge(opts))
+    end
+
+    def edit_privacy(privacy, **opts)
+      call_raw_api("editStoryPrivacy", { story_id: id, privacy: privacy }.merge(opts))
+    end
+
+    def react(reaction)
+      call_raw_api("setStoryReaction", { story_id: id, reaction: reaction })
+    end
+
+    def forward(chat_id:)
+      call_raw_api("forwardStory", { story_id: id, chat_id: chat_id })
+    end
+
+    def download(file_name = "story.dat")
+      call_raw_api("downloadFile", { story_id: id, file_name: file_name })
+    end
+
+    def read
+      call_raw_api("readChatStories", { story_id: id })
+    end
+
+    def view
+      call_raw_api("viewStories", { story_ids: [id] })
+    end
+  end
+
+  class Folder < BaseObject
+    fields :id, :name
+
+    def delete
+      call_raw_api("deleteFolder", { folder_id: id })
+    end
+
+    def edit(**opts)
+      call_raw_api("editFolder", { folder_id: id }.merge(opts))
+    end
+  end
+
+  class ActiveSession < BaseObject
+    fields :hash
+
+    def reset
+      call_raw_api("resetSession", { session_hash: self["hash"] || hash })
+    end
+  end
+
+  class Gift < BaseObject
+    fields :id, :owned_gift_id
+
+    def show
+      call_raw_api("showGift", gift_payload)
+    end
+
+    def hide
+      call_raw_api("hideGift", gift_payload)
+    end
+
+    def convert
+      call_raw_api("convertGiftToStars", gift_payload)
+    end
+
+    def upgrade(**opts)
+      call_raw_api("upgradeGift", gift_payload.merge(opts))
+    end
+
+    def transfer(user_id:, **opts)
+      call_raw_api("transferGift", gift_payload.merge(user_id: user_id).merge(opts))
+    end
+
+    def wear
+      call_raw_api("setProfileGift", gift_payload)
+    end
+
+    def buy(**opts)
+      call_raw_api("sendGift", gift_payload.merge(opts))
+    end
+
+    def send(user_id:, **opts)
+      call_raw_api("sendGift", gift_payload.merge(user_id: user_id).merge(opts))
+    end
+
+    def get_auction_state
+      call_raw_api("getGiftAuctionState", gift_payload)
+    end
+
+    def send_purchase_offer(**opts)
+      call_raw_api("sendGiftPurchaseOffer", gift_payload.merge(opts))
+    end
+
+    private
+
+    def gift_payload
+      { gift_id: self["id"] || id, owned_gift_id: self["owned_gift_id"] || owned_gift_id }.compact
+    end
+  end
+
+  class Animation < BaseObject
+    def add_to_gifs
+      file_id = self["file_id"] || dig("file_id")
+      call_raw_api("addToGifs", { file_id: file_id })
+    end
+  end
+end

data/lib/grubY/types/chat.rb

@@ -0,0 +1,93 @@
+require_relative "base_object"
+
+module GrubY
+  class Chat < BaseObject
+    fields :id, :type, :title, :username, :first_name, :last_name,
+      :is_forum, :is_direct_messages
+
+    def archive
+      call_raw_api("archiveChats", { chat_ids: [id] })
+    end
+
+    def unarchive
+      call_raw_api("unarchiveChats", { chat_ids: [id] })
+    end
+
+    def set_title(title)
+      call_api("setChatTitle", { chat_id: id, title: title.to_s })
+    end
+
+    def set_description(description)
+      call_api("setChatDescription", { chat_id: id, description: description.to_s })
+    end
+
+    def set_photo(photo, **opts)
+      call_api("setChatPhoto", { chat_id: id, photo: photo }.merge(opts))
+    end
+
+    def set_ttl(message_auto_delete_time)
+      call_api("setChatMessageAutoDeleteTime", { chat_id: id, message_auto_delete_time: message_auto_delete_time.to_i })
+    end
+
+    def ban_member(user_id, **opts)
+      call_api("banChatMember", { chat_id: id, user_id: user_id }.merge(opts))
+    end
+
+    def unban_member(user_id, **opts)
+      call_api("unbanChatMember", { chat_id: id, user_id: user_id }.merge(opts))
+    end
+
+    def restrict_member(user_id, permissions:, **opts)
+      call_api("restrictChatMember", { chat_id: id, user_id: user_id, permissions: permissions }.merge(opts))
+    end
+
+    def promote_member(user_id, **opts)
+      call_api("promoteChatMember", { chat_id: id, user_id: user_id }.merge(opts))
+    end
+
+    def join
+      call_api("joinChat", { chat_id: id })
+    end
+
+    def leave
+      call_api("leaveChat", { chat_id: id })
+    end
+
+    def export_invite_link
+      call_api("exportChatInviteLink", { chat_id: id })
+    end
+
+    def get_member(user_id)
+      call_api("getChatMember", { chat_id: id, user_id: user_id })
+    end
+
+    def get_members(**opts)
+      call_raw_api("getChatAdministrators", { chat_id: id }.merge(opts))
+    end
+
+    def add_members(user_ids)
+      ids = Array(user_ids)
+      call_api("addChatMembers", { chat_id: id, user_ids: ids })
+    end
+
+    def mark_unread
+      call_raw_api("markChatUnread", { chat_id: id, is_marked_as_unread: true })
+    end
+
+    def set_protected_content(enabled: true)
+      call_raw_api("setChatProtectedContent", { chat_id: id, has_protected_content: enabled })
+    end
+
+    def unpin_all_messages
+      call_api("unpinAllChatMessages", { chat_id: id })
+    end
+
+    def mute
+      call_raw_api("setChatNotificationSettings", { chat_id: id, mute_for: 2_147_483_647 })
+    end
+
+    def unmute
+      call_raw_api("setChatNotificationSettings", { chat_id: id, mute_for: 0 })
+    end
+  end
+end

data/lib/grubY/types/chat_info.rb

@@ -0,0 +1,31 @@
+require_relative "base_object"
+require_relative "chat"
+
+module GrubY
+  class ChatFullInfo < BaseObject
+    fields :id, :type, :title, :username, :first_name, :last_name, :is_forum,
+      :is_direct_messages, :accent_color_id, :max_reaction_count, :photo,
+      :active_usernames, :birthdate, :business_intro, :business_location,
+      :business_opening_hours, :personal_chat, :parent_chat,
+      :available_reactions, :background_custom_emoji_id,
+      :profile_accent_color_id, :profile_background_custom_emoji_id,
+      :emoji_status_custom_emoji_id, :emoji_status_expiration_date, :bio,
+      :has_private_forwards, :has_restricted_voice_and_video_messages,
+      :join_to_send_messages, :join_by_request, :description, :invite_link,
+      :pinned_message, :permissions, :accepted_gift_types,
+      :can_send_paid_media, :slow_mode_delay, :unrestrict_boost_count,
+      :message_auto_delete_time, :has_aggressive_anti_spam_enabled,
+      :has_hidden_members, :has_protected_content, :has_visible_history,
+      :sticker_set_name, :can_set_sticker_set,
+      :custom_emoji_sticker_set_name, :linked_chat_id, :location, :rating,
+      :first_profile_audio, :unique_gift_colors, :paid_message_star_count
+
+    def initialize(data)
+      super(data)
+      @personal_chat = Chat.new(@personal_chat) if @personal_chat.is_a?(Hash)
+      @parent_chat = Chat.new(@parent_chat) if @parent_chat.is_a?(Hash)
+    end
+  end
+
+  ChatInfo = ChatFullInfo
+end

data/lib/grubY/types/extra.rb

@@ -0,0 +1,251 @@
+require_relative "base_object"
+require_relative "chat"
+require_relative "user"
+require_relative "message_entity"
+
+module GrubY
+  class MessageId < BaseObject
+    fields :message_id
+  end
+
+  class InaccessibleMessage < BaseObject
+    fields :chat, :message_id, :date
+
+    def initialize(data)
+      super(data)
+      @chat = Chat.new(@chat) if @chat.is_a?(Hash)
+    end
+  end
+
+  class MaybeInaccessibleMessage < BaseObject
+    fields :raw
+
+    def initialize(data)
+      super({ raw: data })
+    end
+
+    def inaccessible?
+      @raw.is_a?(Hash) && @raw["date"].to_i.zero?
+    end
+
+    def as_inaccessible
+      return nil unless inaccessible?
+
+      InaccessibleMessage.new(@raw)
+    end
+  end
+
+  class TextQuote < BaseObject
+    fields :text, :entities, :position, :is_manual
+
+    def initialize(data)
+      super(data)
+      @entities = Array(@entities).map { |e| MessageEntity.new(e) }
+    end
+  end
+
+  class ExternalReplyInfo < BaseObject
+    fields :origin, :chat, :message_id, :link_preview_options, :animation, :audio,
+      :document, :paid_media, :photo, :sticker, :story, :video, :video_note,
+      :voice, :has_media_spoiler, :checklist, :contact, :dice, :game,
+      :giveaway, :giveaway_winners, :invoice, :location, :poll, :venue
+
+    def initialize(data)
+      super(data)
+      @chat = Chat.new(@chat) if @chat.is_a?(Hash)
+    end
+  end
+
+  class MessageOrigin < BaseObject
+    fields :type, :date
+  end
+
+  class MessageOriginUser < MessageOrigin
+    fields :sender_user
+
+    def initialize(data)
+      super(data)
+      @sender_user = User.new(@sender_user) if @sender_user.is_a?(Hash)
+    end
+  end
+
+  class MessageOriginHiddenUser < MessageOrigin
+    fields :sender_user_name
+  end
+
+  class MessageOriginChat < MessageOrigin
+    fields :sender_chat, :author_signature
+
+    def initialize(data)
+      super(data)
+      @sender_chat = Chat.new(@sender_chat) if @sender_chat.is_a?(Hash)
+    end
+  end
+
+  class MessageOriginChannel < MessageOrigin
+    fields :chat, :message_id, :author_signature
+
+    def initialize(data)
+      super(data)
+      @chat = Chat.new(@chat) if @chat.is_a?(Hash)
+    end
+  end
+
+  class PhotoSize < BaseObject
+    fields :file_id, :file_unique_id, :width, :height, :file_size
+  end
+
+  class Animation < BaseObject
+    fields :file_id, :file_unique_id, :width, :height, :duration, :thumbnail,
+      :file_name, :mime_type, :file_size
+
+    def initialize(data)
+      super(data)
+      @thumbnail = PhotoSize.new(@thumbnail) if @thumbnail.is_a?(Hash)
+    end
+  end
+
+  class Audio < BaseObject
+    fields :file_id, :file_unique_id, :duration, :performer, :title, :file_name,
+      :mime_type, :file_size, :thumbnail
+
+    def initialize(data)
+      super(data)
+      @thumbnail = PhotoSize.new(@thumbnail) if @thumbnail.is_a?(Hash)
+    end
+  end
+
+  class Document < BaseObject
+    fields :file_id, :file_unique_id, :thumbnail, :file_name, :mime_type,
+      :file_size
+
+    def initialize(data)
+      super(data)
+      @thumbnail = PhotoSize.new(@thumbnail) if @thumbnail.is_a?(Hash)
+    end
+  end
+
+  class Story < BaseObject
+    fields :chat, :id
+
+    def initialize(data)
+      super(data)
+      @chat = Chat.new(@chat) if @chat.is_a?(Hash)
+    end
+  end
+
+  class VideoQuality < BaseObject
+    fields :file_id, :file_unique_id, :width, :height, :codec, :file_size
+  end
+
+  class Video < BaseObject
+    fields :file_id, :file_unique_id, :width, :height, :duration, :thumbnail,
+      :cover, :start_timestamp, :qualities, :file_name, :mime_type, :file_size
+
+    def initialize(data)
+      super(data)
+      @thumbnail = PhotoSize.new(@thumbnail) if @thumbnail.is_a?(Hash)
+      @cover = Array(@cover).map { |c| PhotoSize.new(c) }
+      @qualities = Array(@qualities).map { |q| VideoQuality.new(q) }
+    end
+  end
+
+  class VideoNote < BaseObject
+    fields :file_id, :file_unique_id, :length, :duration, :thumbnail, :file_size
+
+    def initialize(data)
+      super(data)
+      @thumbnail = PhotoSize.new(@thumbnail) if @thumbnail.is_a?(Hash)
+    end
+  end
+
+  class Voice < BaseObject
+    fields :file_id, :file_unique_id, :duration, :mime_type, :file_size
+  end
+
+  class PaidMediaInfo < BaseObject
+    fields :star_count, :paid_media
+  end
+
+  class PaidMedia < BaseObject
+    fields :type
+  end
+
+  class PaidMediaPreview < PaidMedia
+    fields :width, :height, :duration
+  end
+
+  class PaidMediaPhoto < PaidMedia
+    fields :photo
+
+    def initialize(data)
+      super(data)
+      @photo = Array(@photo).map { |p| PhotoSize.new(p) }
+    end
+  end
+
+  class PaidMediaVideo < PaidMedia
+    fields :video
+
+    def initialize(data)
+      super(data)
+      @video = Video.new(@video) if @video.is_a?(Hash)
+    end
+  end
+
+  class Contact < BaseObject
+    fields :phone_number, :first_name, :last_name, :user_id, :vcard
+  end
+
+  class Dice < BaseObject
+    fields :emoji, :value
+  end
+
+  class PollOption < BaseObject
+    fields :persistent_id, :text, :text_entities, :voter_count, :added_by_user,
+      :added_by_chat, :addition_date
+
+    def initialize(data)
+      super(data)
+      @text_entities = Array(@text_entities).map { |e| MessageEntity.new(e) }
+      @added_by_user = User.new(@added_by_user) if @added_by_user.is_a?(Hash)
+      @added_by_chat = Chat.new(@added_by_chat) if @added_by_chat.is_a?(Hash)
+    end
+  end
+
+  class InputPollOption < BaseObject
+    fields :text, :text_parse_mode, :text_entities
+  end
+
+  class PollAnswer < BaseObject
+    fields :poll_id, :voter_chat, :user, :option_ids, :option_persistent_ids
+
+    def initialize(data)
+      super(data)
+      @voter_chat = Chat.new(@voter_chat) if @voter_chat.is_a?(Hash)
+      @user = User.new(@user) if @user.is_a?(Hash)
+    end
+  end
+
+  class Poll < BaseObject
+    fields :id, :question, :question_entities, :options, :total_voter_count,
+      :is_closed, :is_anonymous, :type, :allows_multiple_answers,
+      :allows_revoting, :correct_option_ids, :explanation,
+      :explanation_entities, :open_period, :close_date, :description,
+      :description_entities
+
+    def initialize(data)
+      super(data)
+      @question_entities = Array(@question_entities).map { |e| MessageEntity.new(e) }
+      @options = Array(@options).map { |o| PollOption.new(o) }
+      @explanation_entities = Array(@explanation_entities).map { |e| MessageEntity.new(e) }
+      @description_entities = Array(@description_entities).map { |e| MessageEntity.new(e) }
+    end
+  end
+
+  class ReplyParameters < BaseObject
+    fields :message_id, :chat_id, :allow_sending_without_reply, :quote,
+      :quote_parse_mode, :quote_entities, :quote_position, :checklist_task_id,
+      :poll_option_id
+  end
+end