chatgpt_assistant 0.1.2 → 0.1.4

data/lib/bots/telegram_bot.rb

@@ -1,277 +1,162 @@
 # frozen_string_literal: true
 
+require_relative "helpers/telegram_helper"
+
 module ChatgptAssistant
   # This class is responsible for the telegram bot features
   class TelegramBot < ApplicationBot
     def start
       bot.listen do |message|
+        next if message.chat.type != "private" # disable group and channel messages, we will enable it later
+
         @msg = message
-        event_callback
+        @visitor = telegram_visited?(@msg.chat.id)
+        next unless telegram_text_or_audio?
+
+        text_events if telegram_message_has_text?
+        audio_event if telegram_message_has_audio?
       end
-    rescue StandardError
+    rescue StandardError => e
+      Error.create(message: e.message, backtrace: e.backtrace)
       retry
     end
 
     private
 
-    attr_accessor :msg
-
-    def event_callback
-      return unless text_or_audio?
+      include TelegramHelper
+
+      attr_accessor :msg, :visitor, :chat, :chat_id
+
+      def text_events
+        case msg.text
+        when "/start"
+          start_event
+        when "/help"
+          help_event
+        when "/hist"
+          hist_event
+        when "/list"
+          list_event
+        when "/stop"
+          stop_event
+        when nil
+          nil_event
+        else
+          action_events
+        end
+      end
 
-      text_events if msg.text.present?
-      audio_event if msg.audio.present? || msg.voice.present?
-    end
+      def start_event
+        register_visitor_action("start", visitor.id) unless visitor.tel_user
+        register_user_action("start", visitor.tel_user.id) if visitor.tel_user
+        telegram_send_start_message
+      end
 
-    def text_events
-      case msg.text
-      when "/start"
-        start_event
-      when "/help"
-        help_event
-      when "/list"
-        list_event
-      when "/stop"
-        stop_event
-      when "/hist"
-        hist_event
-      when nil
-        nil_event
-      else
-        action_events
+      def help_event
+        register_visitor_action("help", visitor.id) unless visitor.tel_user
+        register_user_action("help", visitor.tel_user.id) if visitor.tel_user
+        help_messages.each { |m| send_message m, msg.chat.id }
       end
-    end
 
-    def audio_event
-      return bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected]) if user.current_chat.nil?
+      def hist_event
+        return not_logged_in_message unless user
+        return no_chat_selected_message unless user.current_chat
+        return no_messages_founded_message if user.current_chat.messages.count.zero?
 
-      chat = user.current_chat
-      user_audio = transcribed_file
-      message = Message.new(content: user_audio["text"], chat_id: chat.id, role: "user")
-      if message.save
-        ai_text = chatter.chat(user_audio["text"], chat.id)
-        ai_voice = audio_synthesis.synthesize_text(ai_text)
-        send_audio_message(ai_voice, ai_text)
-        delete_all_voice_files
-      else
-        bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:message_creation_error])
+        register_user_action("hist", user.id)
+        telegram_user_history.each do |m|
+          send_message m, msg.chat.id
+        end
       end
-    end
 
-    def send_audio_message(voice, text)
-      bot.api.send_voice(chat_id: msg.chat.id, voice: Faraday::UploadIO.new(voice, "audio/mp3"))
-      bot.api.send_message(chat_id: msg.chat.id, text: text)
-    end
+      def list_event
+        return unless valid_for_list_action?
 
-    def action_events
-      return chatter_call unless actions?
-      return new_chat if msg.text.include?("new_chat/")
-      return select_chat if msg.text.include?("sl_chat/")
-      return login if msg.text.include?("login/")
-      return register if msg.text.include?("register/")
+        register_user_action("list", user.id)
+        send_message commom_messages[:chat_list], msg.chat.id
+        chats_str = ""
+        user.chats.each_with_index { |c, i| chats_str += "Chat #{i + 1} - #{c.title}\n" }
+        send_message chats_str, msg.chat.id
+      end
 
-      invalid_command_error_message
-    end
+      def action_events
+        return login_event if msg.text.include?("login/")
+        return register_event if msg.text.include?("register/")
+        return new_chat_event if msg.text.include?("new_chat/")
+        return select_chat_event if msg.text.include?("sl_chat/")
+        return telegram_chat_event unless telegram_actions?
 
-    def login
-      user_info = msg.text.split("/").last
-      email, password = user_info.split(":")
-      case auth_usertelegram(email, password, msg.chat.id)
-      when "user not found"
-        user_not_found_error_message
-      when "wrong password"
-        wrong_password_error_message
-      when find_useremail(email)
-        user_logged_in_message
+        invalid_command_error_message
       end
-    end
 
-    def register
-      user_info = msg.text.split("/").last
-      email, password = user_info.split(":")
-      if telegram_user_create(msg.chat.id, email, password, msg.from.username || msg.from.first_name)
-        user_created_message
-      else
-        user_creation_error_message
+      def login_event
+        register_visitor_action("login", visitor.id) unless visitor.tel_user
+        user_info = msg.text.split("/").last
+        email, password = user_info.split(":")
+        case telegram_user_auth(email, password, msg.chat.id)
+        when "user not found"
+          user_not_found_error_message
+        when "wrong password"
+          wrong_password_error_message
+        when email
+          user_logged_in_message
+        end
       end
-    end
-
-    def audio
-      msg.audio || msg.voice
-    end
-
-    def audio_info
-      bot.api.get_file(file_id: audio.file_id)
-    end
-
-    def audio_url
-      "https://api.telegram.org/file/bot#{telegram_token}/#{audio_info["result"]["file_path"]}"
-    end
 
-    def transcribed_file
-      audio_recognition.transcribe_audio(audio_url)
-    end
-
-    def start_event
-      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:start])
-      help_message = help_messages.join("\n").to_s
-      bot.api.send_message(chat_id: msg.chat.id, text: help_message)
-      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:start_helper])
-      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:start_sec_helper])
-    end
-
-    def hist_event
-      return not_logged_in_message unless user
-      return bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected]) unless user.current_chat
-
-      if user.current_chat.messages.count.zero?
-        return bot.api.send_message(chat_id: msg.chat.id,
-                                    text: error_messages[:no_messages_founded])
+      def register_event
+        register_visitor_action("register", visitor.id)
+        user_info = msg.text.split("/").last
+        email, password = user_info.split(":")
+        registered_email = telegram_user_create visitor.id, email, password
+        registered_email == email ? user_created_message : user_creation_error_message
       end
 
-      response = chat.messages.last(4).map do |mess|
-        "#{mess.role}: #{mess.content}\n at: #{mess.created_at}\n\n"
-      end.join
-      bot.api.send_message(chat_id: msg.chat.id, text: response)
-    end
-
-    def select_chat
-      return not_logged_in_message unless user
-
-      title = msg.text.split("/").last
-      chat = user.chat_by_title(title)
-      return chat_not_found_message unless chat
-
-      user.update(current_chat_id: chat.id)
-      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:chat_selected])
-    end
+      def new_chat_event
+        return not_logged_in_message unless user
 
-    def new_chat
-      user.nil? ? not_logged_in_message : create_chat
-    end
-
-    def create_chat
-      text = msg.text
-      title = text.split("/").last
-      chat = Chat.new(user_id: user.id, status: 0, title: title)
-      chat.save ? chat_created_message(chat) : chat_creation_failed_message
-    end
-
-    def list_event
-      return unless valid_for_list_action?
-
-      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:chat_list])
-      chats_str = ""
-      user.chats.each do |chat|
-        chats_str += "Chat #{chat.id} - #{chat.title}\n"
+        register_user_action("new_chat", user.id)
+        telegram_create_chat
       end
-      bot.api.send_message(chat_id: msg.chat.id, text: chats_str)
-    end
-
-    def valid_for_list_action?
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:not_logged_in]) if user.nil?
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:no_chats_founded]) if user.chats.count.zero?
-      !user.nil? && user.chats.count.positive?
-    end
-
-    def chatter_call
-      user ? chat_if_exists : not_logged_in_message
-    end
 
-    def chat_if_exists
-      chat = Chat.find_by(user_id: user.id, id: user.current_chat_id)
-      chat ? chat_success(chat.id) : no_chat_selected
-    end
+      def select_chat_event
+        return not_logged_in_message unless user
 
-    def chat_success(chat_id)
-      Message.create(chat_id: chat_id, content: msg.text, role: "user")
-      bot.api.send_message(chat_id: msg.chat.id, text: chatter.chat(msg.text, chat_id))
-    end
+        register_user_action("select_chat", user.id)
+        title = msg.text.split("/").last
+        chat = user.chat_by_title(title)
+        return chat_not_found_message unless chat
 
-    def help_event
-      help_messages.each do |message|
-        bot.api.send_message(chat_id: msg.chat.id, text: message)
+        user.update(current_chat_id: chat.id)
+        send_message success_messages[:chat_selected], msg.chat.id
       end
-    end
-
-    def stop_event
-      bot.api.send_message(chat_id: msg.chat.id, text: commom_messages[:stop])
-      bot.api.leave_chat(chat_id: msg.chat.id)
-    end
-
-    def nil_event
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:nil])
-    end
-
-    def user_logged_message
-      user.update(telegram_id: msg.chat.id)
-      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in])
-    end
-
-    def invalid_command_error_message
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:invalid_command])
-    end
-
-    def wrong_password_error_message
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:password])
-    end
-
-    def user_not_found_error_message
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_found])
-    end
-
-    def not_logged_in_message
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_logged_in])
-    end
-
-    def user_created_message
-      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:user_created])
-    end
 
-    def user_creation_error_message
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:user_creation])
-    end
-
-    def chat_created_message(chat)
-      user.update(current_chat_id: chat.id)
-      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:chat_created])
-    end
-
-    def chat_creation_failed_message
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:chat_creation_failed])
-    end
-
-    def no_chat_selected
-      bot.api.send_message(chat_id: msg.chat.id,
-                           text: error_messages[:no_chat_selected])
-    end
-
-    def chat_not_found_message
-      bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:chat_not_found])
-    end
-
-    def error_log(err)
-      if err.message.to_s.include?("Bad Request: message is too long")
-        bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:message_history_too_long])
-      else
-        bot.api.send_message(chat_id: msg.chat.id, text: error_messages[:something_went_wrong])
+      def stop_event
+        register_event_action("stop", visitor.id) unless visitor.tel_user
+        register_user_action("stop", visitor.tel_user.id) if visitor.tel_user
+        send_message commom_messages[:stop], msg.chat.id
+        bot.api.leave_chat(chat_id: msg.chat.id)
       end
-    end
-
-    def user
-      @user ||= User.find_by(telegram_id: msg.chat.id)
-    end
-
-    def bot
-      @bot ||= Telegram::Bot::Client.new(telegram_token)
-    end
 
-    def text_or_audio?
-      msg.respond_to?(:text) || msg.respond_to?(:audio) || msg.respond_to?(:voice)
-    end
+      def nil_event
+        register_event_action("nil", visitor.id) unless visitor.tel_user
+        register_user_action("nil", visitor.tel_user.id) if visitor.tel_user
+        send_message error_messages[:nil], msg.chat.id
+      end
 
-    def actions?
-      msg.text.include?("new_chat/") || msg.text.include?("sl_chat/") || msg.text.include?("login/") || msg.text.include?("register/")
-    end
+      def audio_event
+        return not_logged_in_message unless user
+        return no_chat_selected_message if user.current_chat_id.nil?
+
+        register_user_action("audio", user.id)
+        user_audio = transcribe_file(telegram_audio_url)
+        message = Message.new(content: user_audio[:text], chat_id: user.current_chat_id, role: "user")
+        if message.save
+          ai_response = telegram_process_ai_voice(user_audio[:file])
+          telegram_send_voice_message(voice: ai_response[:voice], text: ai_response[:text])
+          delete_file ai_response[:voice]
+        else
+          send_message error_messages[:message_creation_error], msg.chat.id
+        end
+      end
   end
 end

data/lib/chatgpt_assistant/audio_recognition.rb

@@ -15,38 +15,7 @@ module ChatgptAssistant
       @openai_api_key = openai_api_key
     end
 
-    def download_audio(audio_url)
-      audio_conn = Faraday.new(url: audio_url)
-      File.open(dl_file_name, "wb") do |file|
-        file.write(audio_conn.get.body)
-      end
-      FFMPEG::Movie.new(dl_file_name).transcode(file_name)
-      File.delete(dl_file_name)
-    end
-
-    def header
-      {
-        "Content-Type": "multipart/form-data",
-        "Authorization": "Bearer #{openai_api_key}"
-      }
-    end
-
-    def payload
-      {
-        "file": Faraday::UploadIO.new(file_name, "audio/mp3"),
-        "model": "whisper-1"
-      }
-    end
-
-    def transcribed_file_json
-      {
-        file_name: file_name,
-        text: JSON.parse(response.body)["text"]
-      }.to_json
-    end
-
     def transcribe_audio(audio_url)
-      @audio_url = audio_url
       download_audio(audio_url)
       @response = conn.post("v1/audio/transcriptions", payload, header)
       transcribed_file_json
@@ -54,6 +23,36 @@ module ChatgptAssistant
 
     private
 
-    attr_reader :conn, :openai_api_key, :audio_url, :time, :ibm_api_key, :ibm_url, :response, :dl_file_name, :file_name
+      attr_reader :conn, :time,
+                  :response, :dl_file_name, :file_name,
+                  :ibm_api_key, :ibm_url, :openai_api_key
+
+      def download_audio(audio_url)
+        audio_conn = Faraday.new(url: audio_url)
+        File.binwrite(dl_file_name, audio_conn.get.body)
+        FFMPEG::Movie.new(dl_file_name).transcode(file_name)
+        File.delete(dl_file_name)
+      end
+
+      def header
+        {
+          "Content-Type": "multipart/form-data",
+          Authorization: "Bearer #{openai_api_key}"
+        }
+      end
+
+      def payload
+        {
+          file: Faraday::UploadIO.new(file_name, "audio/mp3"),
+          model: "whisper-1"
+        }
+      end
+
+      def transcribed_file_json
+        {
+          file: file_name,
+          text: JSON.parse(response.body)["text"]
+        }
+      end
   end
 end

data/lib/chatgpt_assistant/audio_synthesis.rb

@@ -22,98 +22,94 @@ module ChatgptAssistant
 
     private
 
-    attr_reader :openai_api_key, :ibm_api_key, :ibm_url, :aws_access_key_id, :aws_secret_access_key, :aws_region,
-                :config, :language, :voice
-
-    def faraday_instance
-      Faraday.new(url: "https://api.openai.com/") do |faraday|
-        faraday.request :multipart
-        faraday.request :url_encoded
-        faraday.adapter Faraday.default_adapter
+      attr_reader :openai_api_key, :ibm_api_key, :ibm_url, :aws_access_key_id, :aws_secret_access_key, :aws_region,
+                  :config, :language, :voice
+
+      def faraday_instance
+        Faraday.new(url: "https://api.openai.com/") do |faraday|
+          faraday.request :multipart
+          faraday.request :url_encoded
+          faraday.adapter Faraday.default_adapter
+        end
       end
-    end
 
-    def classify_mode
-      if ibm_mode?
-        @ibm_api_key = config.ibm_api_key
-        @ibm_url = config.ibm_url
-        @voice = send("#{language}_ibm_voice")
-      elsif aws_mode?
-        @aws_access_key_id = config.aws_access_key_id
-        @aws_secret_access_key = config.aws_secret_access_key
-        @aws_region = config.aws_region
-        @voice = send("#{language}_aws_voice")
+      def classify_mode
+        if ibm_mode?
+          @ibm_api_key = config.ibm_api_key
+          @ibm_url = config.ibm_url
+          @voice = send("#{language}_ibm_voice")
+        elsif aws_mode?
+          @aws_access_key_id = config.aws_access_key_id
+          @aws_secret_access_key = config.aws_secret_access_key
+          @aws_region = config.aws_region
+          @voice = send("#{language}_aws_voice")
+        end
       end
-    end
 
-    def synthesize_text_aws(text)
-      time = Time.now.to_i
-      @time = Time.now.to_i
-      polly_client = Aws::Polly::Client.new(
-        access_key_id: aws_access_key_id,
-        secret_access_key: aws_secret_access_key,
-        region: aws_region
-      )
-      response = polly_client.synthesize_speech(
-        output_format: "mp3",
-        text: text,
-        voice_id: voice,
-        engine: "neural"
-      )
-
-      File.open("voice/aws-#{time}.mp3", "wb") do |file|
-        file.write(response.audio_stream.read)
+      def synthesize_text_aws(text)
+        time = Time.now.to_i
+        @time = Time.now.to_i
+        polly_client = Aws::Polly::Client.new(
+          access_key_id: aws_access_key_id,
+          secret_access_key: aws_secret_access_key,
+          region: aws_region
+        )
+        response = polly_client.synthesize_speech(
+          output_format: "mp3",
+          text: text,
+          voice_id: voice,
+          engine: "neural"
+        )
+
+        File.binwrite("voice/aws-#{time}.mp3", response.audio_stream.read)
+        "voice/aws-#{time}.mp3"
       end
-      "voice/aws-#{time}.mp3"
-    end
 
-    def synthesize_text_ibm(text)
-      time = Time.now.to_i
-      authenticator = IBMWatson::Authenticators::IamAuthenticator.new(
-        apikey: ibm_api_key
-      )
+      def synthesize_text_ibm(text)
+        time = Time.now.to_i
+        authenticator = IBMWatson::Authenticators::IamAuthenticator.new(
+          apikey: ibm_api_key
+        )
 
-      text_to_speech = IBMWatson::TextToSpeechV1.new(
-        authenticator: authenticator
-      )
+        text_to_speech = IBMWatson::TextToSpeechV1.new(
+          authenticator: authenticator
+        )
 
-      text_to_speech.service_url = ibm_url
+        text_to_speech.service_url = ibm_url
 
-      audio_format = "audio/mp3"
-      audio = text_to_speech.synthesize(
-        text: text,
-        accept: audio_format,
-        voice: voice
-      ).result
+        audio_format = "audio/mp3"
+        audio = text_to_speech.synthesize(
+          text: text,
+          accept: audio_format,
+          voice: voice
+        ).result
 
-      File.open("voice/ibm-#{time}.mp3", "wb") do |audio_file|
-        audio_file.write(audio)
+        File.binwrite("voice/ibm-#{time}.mp3", audio)
+        "voice/ibm-#{time}.mp3"
       end
-      "voice/ibm-#{time}.mp3"
-    end
 
-    def pt_aws_voice
-      "Vitoria"
-    end
+      def pt_aws_voice
+        "Vitoria"
+      end
 
-    def en_aws_voice
-      "Joanna"
-    end
+      def en_aws_voice
+        "Joanna"
+      end
 
-    def pt_ibm_voice
-      "pt-BR_IsabelaV3Voice"
-    end
+      def pt_ibm_voice
+        "pt-BR_IsabelaV3Voice"
+      end
 
-    def en_ibm_voice
-      "en-US_AllisonV3Voice"
-    end
+      def en_ibm_voice
+        "en-US_AllisonV3Voice"
+      end
 
-    def ibm_mode?
-      config.mode == "ibm"
-    end
+      def ibm_mode?
+        config.mode == "ibm"
+      end
 
-    def aws_mode?
-      config.mode == "aws"
-    end
+      def aws_mode?
+        config.mode == "aws"
+      end
   end
 end