telegram_workflow 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "telegram_workflow"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/telegram_workflow.rb

@@ -0,0 +1,38 @@
+require "http"
+
+module TelegramWorkflow
+  module Stores
+  end
+
+  def self.process(params)
+    Workflow.new(params).process
+  end
+
+  def self.updates(offset: nil, limit: nil, timeout: 60, allowed_updates: nil)
+    params = {}
+    params[:offset] = offset if offset
+    params[:limit] = limit if limit
+    params[:timeout] = timeout if timeout
+    params[:allowed_updates] = allowed_updates if allowed_updates
+
+    Updates.new(params).enum
+  end
+end
+
+require "telegram_workflow/action"
+require "telegram_workflow/client"
+require "telegram_workflow/config"
+require "telegram_workflow/errors"
+require "telegram_workflow/params"
+require "telegram_workflow/session"
+require "telegram_workflow/version"
+require "telegram_workflow/updates"
+require "telegram_workflow/workflow"
+require "telegram_workflow/stores/in_memory"
+require "telegram_workflow/stores/file"
+
+TelegramWorkflow.__after_configuration do |config|
+  if config.webhook_url
+    TelegramWorkflow::Client.new.__setup_webhook
+  end
+end

data/lib/telegram_workflow/action.rb

@@ -0,0 +1,44 @@
+class TelegramWorkflow::Action
+  extend ::Forwardable
+  def_delegators :@__workflow, :client, :params, :redirect_to
+
+  def initialize(workflow, session, flash)
+    @__workflow = workflow
+    @__session = session
+    @__flash = flash
+  end
+
+  def shared
+    :__continue
+  end
+
+  def on_redirect(&block)
+    @on_redirect = block
+  end
+
+  def on_message(&block)
+    @on_message = block
+  end
+
+  def __reset_callbacks
+    @on_redirect = @on_message = nil
+  end
+
+  def __run_on_redirect
+    @on_redirect.call if @on_redirect
+  end
+
+  def __run_on_message
+    @on_message.call if @on_message
+  end
+
+  private
+
+  def session
+    @__session
+  end
+
+  def flash
+    @__flash
+  end
+end

data/lib/telegram_workflow/client.rb

@@ -0,0 +1,140 @@
+class TelegramWorkflow::Client
+  API_VERSION = "4.8"
+  WebhookFilePath = Pathname.new("tmp/telegram_workflow/webhook_url.txt")
+
+  AVAILABLE_ACTIONS = %i(
+    getUpdates
+    getWebhookInfo
+
+    getMe
+    sendMessage
+    forwardMessage
+    sendPhoto
+    sendAudio
+    sendDocument
+    sendVideo
+    sendAnimation
+    sendVoice
+    sendVideoNote
+    sendMediaGroup
+    sendLocation
+    editMessageLiveLocation
+    stopMessageLiveLocation
+    sendVenue
+    sendContact
+    sendPoll
+    sendDice
+    sendChatAction
+    getUserProfilePhotos
+    getFile
+    kickChatMember
+    unbanChatMember
+    restrictChatMember
+    promoteChatMember
+    setChatAdministratorCustomTitle
+    setChatPermissions
+    exportChatInviteLink
+    setChatPhoto
+    deleteChatPhoto
+    setChatTitle
+    setChatDescription
+    pinChatMessage
+    unpinChatMessage
+    leaveChat
+    getChat
+    getChatAdministrators
+    getChatMembersCount
+    getChatMember
+    setChatStickerSet
+    deleteChatStickerSet
+    answerCallbackQuery
+    setMyCommands
+    getMyCommands
+
+    editMessageText
+    editMessageCaption
+    editMessageMedia
+    editMessageReplyMarkup
+    stopPoll
+    deleteMessage
+
+    sendSticker
+    getStickerSet
+    uploadStickerFile
+    createNewStickerSet
+    addStickerToSet
+    setStickerPositionInSet
+    deleteStickerFromSet
+    setStickerSetThumb
+
+    answerInlineQuery
+
+    sendInvoice
+    answerShippingQuery
+    answerPreCheckoutQuery
+
+    setPassportDataErrors
+
+    sendGame
+    setGameScore
+    getGameHighScores
+  )
+
+  AVAILABLE_ACTIONS.each do |action|
+    method_name = action.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+
+    define_method(method_name) do |params = {}|
+      make_request(action, params)
+    end
+  end
+
+  def initialize(chat_id = nil)
+    @chat_id = chat_id
+    @webhook_url = TelegramWorkflow.config.webhook_url
+    @api_url = "https://api.telegram.org/bot#{TelegramWorkflow.config.api_token}"
+  end
+
+  def set_webhook(params = {})
+    make_request("setWebhook", params)
+    cached_webhook_url(new_url: @webhook_url)
+  end
+
+  def delete_webhook
+    make_request("deleteWebhook", {})
+    cached_webhook_url(new_url: "")
+  end
+
+  def __setup_webhook
+    TelegramWorkflow.config.logger.info "[TelegramWorkflow] Checking webhook setup..."
+
+    if cached_webhook_url != @webhook_url
+      TelegramWorkflow.config.logger.info "[TelegramWorkflow] Setting up a new webhook..."
+      set_webhook(url: @webhook_url)
+    end
+  end
+
+  private
+
+  def cached_webhook_url(new_url: nil)
+    unless WebhookFilePath.exist?
+      WebhookFilePath.dirname.mkpath
+      WebhookFilePath.write("")
+    end
+
+    if new_url.nil?
+      WebhookFilePath.read
+    else
+      WebhookFilePath.write(new_url)
+    end
+  end
+
+  def make_request(action, params)
+    response = ::HTTP.post("#{@api_url}/#{action}", json: { chat_id: @chat_id, **params })
+
+    if response.code != 200
+      raise TelegramWorkflow::Errors::ApiError, response.parse["description"]
+    end
+
+    response.parse
+  end
+end

data/lib/telegram_workflow/config.rb

@@ -0,0 +1,48 @@
+unless defined?(Rails)
+  require "logger"
+end
+
+module TelegramWorkflow
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield(config)
+      config.verify!
+
+      @__after_configuration.call(config)
+    end
+
+    def __after_configuration(&block)
+      @__after_configuration = block
+    end
+  end
+
+  class Configuration
+    attr_accessor :session_store, :logger, :client, :start_action, :webhook_url, :api_token
+
+    REQUIRED_PARAMS = %i(session_store start_action api_token)
+
+    def initialize
+      @client = TelegramWorkflow::Client
+
+      if defined?(Rails)
+        @session_store = Rails.cache
+        @logger = Rails.logger
+      else
+        @session_store = TelegramWorkflow::Stores::InMemory.new
+        @logger = Logger.new(STDOUT)
+      end
+    end
+
+    def verify!
+      blank_params = REQUIRED_PARAMS.select { |p| send(p).nil? }
+
+      if blank_params.any?
+        raise TelegramWorkflow::Errors::MissingConfiguration, blank_params
+      end
+    end
+  end
+end

data/lib/telegram_workflow/errors.rb

@@ -0,0 +1,23 @@
+module TelegramWorkflow::Errors
+  class DoubleRedirect < StandardError
+    def initialize(msg = "Redirect was called multiple times in the step callback.")
+      super
+    end
+  end
+
+  class SharedRedirect < StandardError
+    def initialize(msg = "You cannot redirect to a shared step.")
+      super
+    end
+  end
+
+  class ApiError < StandardError
+  end
+
+  class MissingConfiguration < StandardError
+    def initialize(missing_config_params)
+      msg = "Missing required configuration params: #{missing_config_params.join(", ")}"
+      super(msg)
+    end
+  end
+end

data/lib/telegram_workflow/params.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class TelegramWorkflow::Params
+  def initialize(params)
+    @params = params
+  end
+
+  def [](key)
+    @params[key]
+  end
+
+  def user
+    @user ||= @params.dig("message", "from") ||
+      @params.dig("callback_query", "from") ||
+      @params.dig("pre_checkout_query", "from") ||
+      @params.dig("shipping_query", "from") ||
+      @params.dig("inline_query", "from") ||
+      @params.dig("chosen_inline_result", "from")
+  end
+
+  def language_code
+    user["language_code"]
+  end
+
+  def user_id
+    user["id"]
+  end
+
+  def username
+    user["username"]
+  end
+
+  def chat_id
+    @params.dig("message", "chat", "id") ||
+      @params.dig("callback_query", "message", "chat", "id") ||
+      @params.dig("edited_message", "chat", "id") ||
+      @params.dig("channel_post", "chat", "id") ||
+      @params.dig("edited_channel_post", "chat", "id")
+  end
+
+  def message_text
+    @params.dig("message", "text")
+  end
+
+  def callback_data
+    @params.dig("callback_query", "data")
+  end
+
+  def start?
+    !!message_text&.start_with?("/start")
+  end
+
+  def command?
+    !!message_text&.start_with?("/")
+  end
+
+  def deep_link_payload
+    match = /\A\/(startgroup|start) (?<payload>.+)\z/.match(message_text)
+    match["payload"] if match
+  end
+end

data/lib/telegram_workflow/rspec.rb

@@ -0,0 +1,80 @@
+module TelegramActionExampleGroup
+  def self.included(klass)
+    klass.class_eval do
+      klass.metadata[:type] = :telegram_action
+
+      subject { double(client: spy, flow: spy) }
+
+      let(:current_action) { described_class }
+      let(:action_params) do
+        {
+          "update_id" => 111111111,
+          "message" => {
+            "message_id" => 200,
+            "from" => {
+              "id" => 112233445,
+            },
+            "text" => ""
+          },
+          "callback_query" => {
+            "data" => ""
+          }
+        }
+      end
+
+      before do
+        TelegramWorkflow.config.session_store = TelegramWorkflow::Stores::InMemory.new
+        TelegramWorkflow.config.start_action = TestStartAction
+        send_message message_text: "/start"
+      end
+
+      include InstanceMethods
+    end
+  end
+
+  module InstanceMethods
+    def send_message(message_text: "", callback_data: "")
+      action_params["message"]["text"] = message_text
+      action_params["callback_query"]["data"] = callback_data
+
+      workflow = TestFlow.new(action_params)
+      workflow.example_group = self
+
+      workflow.process
+    end
+  end
+
+  class TestFlow < TelegramWorkflow::Workflow
+    attr_accessor :example_group
+
+    def client
+      example_group.subject.client
+    end
+
+    def redirect_to(action_or_step, session_params = nil)
+      super
+
+      if session_params
+        example_group.subject.flow.send(:redirect_to, action_or_step, session_params)
+      else
+        example_group.subject.flow.send(:redirect_to, action_or_step)
+      end
+    end
+  end
+
+  class TelegramWorkflow::Action
+    def_delegators :@__workflow, :example_group
+  end
+
+  class TestStartAction < TelegramWorkflow::Action
+    def initial
+      on_message { redirect_to example_group.current_action }
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include TelegramActionExampleGroup,
+    type: :telegram_action,
+    file_path: %r(spec/telegram_actions)
+end