chatgpt_assistant 0.1.5 → 0.1.6

data/lib/bots/helpers/messenger_helper.rb

@@ -5,7 +5,7 @@ module ChatgptAssistant
   module MessengerHelper
     def chat_success(chat_id)
       user_message = Message.new(chat_id: chat_id, content: msg.text, role: "user")
-      if user_message.save
+      if user_message&.save
         text = chatter.chat(msg.text, chat_id, error_messages[:something_went_wrong])
         mess = parse_message(text, 4096)
         mess.each { |m| send_message m, msg.chat.id }
@@ -53,27 +53,27 @@ module ChatgptAssistant
 
     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])
+      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in]) if bot.respond_to?(:api)
       evnt&.respond success_messages[:user_logged_in] if evnt.present?
     end
 
     def invalid_command_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:invalid_command])
+      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:invalid_command]) if bot.respond_to?(:api)
       evnt&.respond error_messages[:invalid_command]
     end
 
     def user_not_found_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_found]) if bot.api.present?
+      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_found]) if bot.respond_to?(:api)
       evnt&.respond error_messages[:user_not_found] if evnt.present?
     end
 
     def user_created_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_created]) if bot.api.present?
+      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_created]) if bot.respond_to?(:api)
       evnt&.respond success_messages[:user_created] if evnt.present?
     end
 
     def user_creation_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_creation]) if bot.api.present?
+      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_creation]) if bot.respond_to?(:api)
       evnt&.respond error_messages[:user_creation] if evnt.present?
     end
 
@@ -87,47 +87,46 @@ module ChatgptAssistant
     def telegram_created(chat)
       bot.api.send_message(chat_id: msg.chat.id, text: "Intructions sended to actor:\n#{chat.prompt}") unless chat.actor.nil?
       bot.api.send_message(chat_id: msg.chat.id, text: "Response from assistant:\n#{chat.messages[1].content}") unless chat.actor.nil?
-      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:chat_created]) if bot.api.present?
+      bot.api.send_message(chat_id: msg.chat.id, text: success_messages[:chat_created]) if bot.respond_to?(:api)
     end
 
     def discord_created(chat)
       evnt.respond "Intructions sended to actor:\n#{chat.prompt}" unless chat.actor.nil?
-      evnt.respond "Response from assistant:\n#{chat.messages[1].content}" unless chat.actor.nil?
       evnt.respond success_messages[:chat_created] if evnt.present?
     end
 
     def not_logged_in_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_logged_in])
+      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_logged_in]) if bot.respond_to?(:api)
       evnt&.respond(error_messages[:user_not_logged_in])
     end
 
     def wrong_password_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:password])
+      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:password]) if bot.respond_to?(:api)
       evnt&.respond(error_messages[:password])
     end
 
     def chat_not_found_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:chat_not_found])
+      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:chat_not_found]) if bot.respond_to?(:api)
       evnt&.respond(error_messages[:chat_not_found])
     end
 
     def no_chat_selected_message
-      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected])
+      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected]) if bot.respond_to?(:api)
       evnt&.respond(error_messages[:no_chat_selected])
     end
 
     def no_messages_founded_message
-      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:no_messages_founded])
+      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:no_messages_founded]) if bot.respond_to?(:api)
       evnt&.respond(error_messages[:no_messages_founded])
     end
 
     def chat_creation_failed_message
-      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:chat_creation_failed])
+      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:chat_creation_failed]) if bot.respond_to?(:api)
       evnt&.respond(error_messages[:chat_creation_failed])
     end
 
     def user_logged_in_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in])
+      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in]) if bot.respond_to?(:api)
       evnt&.respond(success_messages[:user_logged_in])
     end
   end

data/lib/bots/helpers/search_helper.rb

@@ -23,11 +23,11 @@ module ChatgptAssistant
 
     def where_user(telegram_id: nil, discord_id: nil, email: nil)
       if telegram_id
-        User.where(telegram_id: telegram_id)
+        User.where(telegram_id: telegram_id).to_a
       elsif discord_id
-        User.where(discord_id: discord_id)
+        User.where(discord_id: discord_id).to_a
       elsif email
-        User.where(email: email)
+        User.where(email: email).to_a
       end
     end
   end

data/lib/bots/helpers/telegram_helper.rb

@@ -25,11 +25,11 @@ module ChatgptAssistant
     end
 
     def telegram_send_start_message
-      send_message commom_messages[:start], msg.chat.id
+      send_message common_messages[:start], msg.chat.id
       help_message = help_messages.join("\n").to_s
       send_message help_message, msg.chat.id
-      send_message commom_messages[:start_helper], msg.chat.id
-      send_message commom_messages[:start_sec_helper], msg.chat.id
+      send_message common_messages[:start_helper], msg.chat.id
+      send_message common_messages[:start_sec_helper], msg.chat.id
     end
 
     def telegram_create_chat
@@ -54,10 +54,6 @@ module ChatgptAssistant
       chat.save ? chat_created_message(chat) : chat_creation_failed_message
     end
 
-    def telegram_user_history
-      user.current_chat.messages.last(10).map { |m| "#{m.role}: #{m.content}\nat: #{m.created_at}" }
-    end
-
     def telegram_text_or_audio?
       msg.respond_to?(:text) || msg.respond_to?(:audio) || msg.respond_to?(:voice)
     end

data/lib/bots/helpers/validation_helper.rb

@@ -27,7 +27,7 @@ module ChatgptAssistant
     end
 
     def discord_next_action?
-      return true if evnt.channel.type != 1
+      return true if evnt.channel.type != 1 && evnt.channel.name != "ai-spaces"
 
       %w[login register start help new_chat sl_chat ask list hist connect disconnect speak].each do |action|
         return true if evnt.message.content.include?("#{discord_prefix}#{action}")

data/lib/bots/helpers/visit_helper.rb

@@ -4,6 +4,8 @@ module ChatgptAssistant
   # Helper for visit
   module VisitHelper
     def telegram_visited?(chat_id)
+      return unless msg
+
       visitor = Visitor.find_by(telegram_id: chat_id, name: msg.from.first_name)
       if visitor.nil?
         Visitor.create(telegram_id: chat_id, name: msg.from.first_name)
@@ -13,6 +15,8 @@ module ChatgptAssistant
     end
 
     def discord_visited?(user_id)
+      return unless evnt
+
       visitor = Visitor.find_by(discord_id: user_id, name: evnt.user.name)
       if visitor.nil?
         Visitor.create(discord_id: user_id, name: evnt.user.name)

data/lib/bots/jobs/new_chat_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module ChatgptAssistant
+  # This class is responsible to background the new chat service
+  class NewChatJob
+    include Sidekiq::Job
+
+    def perform(chat_title, user_id, chat_id)
+      @config = Config.new
+      @config.db_connection
+
+      NewChatService.new(chat_title, user_id, chat_id, @config).call
+    end
+  end
+end

data/lib/bots/jobs/register_job.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module ChatgptAssistant
+  # This class is responsible to background the register service
+  class RegisterJob
+    include Sidekiq::Job
+
+    sidekiq_options queue: :default
+
+    def perform(email, password, chat_id)
+      RegisterService.new(email, password, chat_id).call
+    end
+  end
+end

data/lib/bots/jobs/voice_connect_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module ChatgptAssistant
+  # This class is responsible to background the voice connect service
+  class VoiceConnectJob
+    include Sidekiq::Worker
+
+    def perform(channel_id)
+      VoiceConnectService.new(channel_id).call
+    end
+  end
+end

data/lib/bots/services/new_chat_service.rb

@@ -0,0 +1,34 @@
+#  frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible to background the new chat service
+  class NewChatService
+    def initialize(chat_title, user_id, chat_id, config)
+      @chat_title = chat_title
+      @user_id = user_id
+      @chat_id = chat_id
+      @config = config
+    end
+
+    def telegram_async
+      TelegramBot.new(@config)
+    end
+
+    def call
+      raise ChatAlreadyExistsError if Chat.find_by(title: @chat_title)
+      raise NilError if @chat_title.nil?
+      raise NilError if @user_id.nil?
+      raise NilError if @chat_id.nil?
+
+      chat = Chat.new(title: @chat_title, user_id: @user_id)
+      if chat.save
+        telegram_async.send_message("Chat created succesfully", @chat_id)
+      else
+        raise ChatAlreadyExistsError if Chat.find_by(title: @chat_title)
+        raise NilError if chat.errors[:title].any?
+      end
+    rescue ChatAlreadyExistsError, NilError => e
+      telegram_async.send_message(e.message, @chat_id)
+    end
+  end
+end

data/lib/bots/services/register_service.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible to background the register service
+  class RegisterService
+    def initialize(email, password, chat_id)
+      @email = email
+      @password = password
+      @chat_id = chat_id
+      @config = Config.new
+      @config.db_connection
+    end
+
+    def telegram_async
+      TelegramBot.new(@config)
+    end
+
+    def call
+      user = User.find_by(email: @email)
+      if user
+        telegram_async.send_message("User already exists", @chat_id)
+      else
+        user = User.new(email: @email, password: @password, telegram_id: @chat_id)
+        if user.save
+          telegram_async.send_message("User created", @chat_id)
+        else
+          raise UserAlreadyExistsError if User.find_by(email: @email)
+          raise WrongEmailError if user.errors[:email].any?
+          raise WrongPasswordError if user.errors[:password].any?
+        end
+      end
+    rescue UserAlreadyExistsError, WrongEmailError, WrongPasswordError => e
+      telegram_async.send_message(e.message, @chat_id)
+    end
+  end
+end

data/lib/bots/services/voice_connect_service.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible to handle the discord bot
+  class VoiceConnectService
+    def initialize(channel_id)
+      @channel_id = channel_id
+      @config = Config.new
+      # @config.db_connection
+    end
+
+    def bot
+      @bot ||= Discordrb::Bot.new(token: @config.discord_token)
+    end
+
+    def call
+      bot.run :async
+      channel = bot.channel(@channel_id)
+
+      bot.voice_connect(channel)
+      bot.join
+      true
+    rescue StandardError => e
+      puts e.message
+      e.backtrace.each { |line| puts line }
+      false
+    end
+  end
+end

data/lib/bots/telegram_bot.rb

@@ -8,8 +8,6 @@ module ChatgptAssistant
   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
         @visitor = telegram_visited?(@msg.chat.id)
         next unless telegram_text_or_audio?
@@ -42,10 +40,12 @@ module ChatgptAssistant
         when "/stop"
           stop_event
         when nil
-          nil_event
+          raise NilError
         else
           action_events
         end
+      rescue NilError => e
+        send_message e.message, msg.chat.id
       end
 
       def start_event
@@ -57,93 +57,124 @@ module ChatgptAssistant
       end
 
       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?
+        raise UserNotLoggedInError if user.nil?
+        raise NoChatSelectedError if user.current_chat.nil?
+        raise NoMessagesFoundedError if user.current_chat.messages.count.zero?
 
-        telegram_user_history.each do |m|
+        user.chat_history.each do |m|
           send_message m, msg.chat.id
         end
+      rescue NoChatSelectedError, UserNotLoggedInError, NoMessagesFoundedError => e
+        send_message e.message, msg.chat.id
       end
 
       def list_event
-        return unless valid_for_list_action?
+        raise UserNotLoggedInError if user.nil?
+        raise NoChatsFoundedError if user.chats.count.zero?
 
-        send_message commom_messages[:chat_list], msg.chat.id
+        send_message common_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
+      rescue NoChatsFoundedError, UserNotLoggedInError => e
+        send_message e.message, msg.chat.id
       end
 
       def action_events
-        return login_event if msg.text.include?("login/")
-        return register_event if msg.text.include?("register/")
+        return auth_events if auth_event?
         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?
 
-        invalid_command_error_message
+        raise InvalidCommandError
+      rescue InvalidCommandError => e
+        send_message e.message, msg.chat.id
+      end
+
+      def auth_event?
+        msg.text.include?("login/") || msg.text.include?("register/") || msg.text.include?("sign_out/")
+      end
+
+      def auth_events
+        return login_event if msg.text.include?("login/")
+        return register_event if msg.text.include?("register/")
+        return sign_out_event if msg.text.include?("sign_out/")
       end
 
       def login_event
+        raise UserLoggedInError if 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
+          raise UserNotFoundError
         when "wrong password"
-          wrong_password_error_message
+          raise WrongPasswordError
         when email
           user_logged_in_message
         end
+      rescue UserNotFoundError, WrongPasswordError, UserLoggedInError => e
+        send_message e.message, msg.chat.id
       end
 
       def register_event
         user_info = msg.text.split("/").last
+        raise NoRegisterInfoError if user_info.nil?
+        raise UserLoggedInError if user
+
         email, password = user_info.split(":")
-        registered_email = telegram_user_create visitor.id, email, password
-        registered_email == email ? user_created_message : user_creation_error_message
+        raise NoRegisterInfoError if email.nil? || password.nil?
+
+        RegisterJob.perform_async(email, password, visitor.telegram_id)
+      rescue NoRegisterInfoError, UserLoggedInError => e
+        send_message e.message, msg.chat.id
+      end
+
+      def sign_out_event
+        raise UserNotLoggedInError if user.nil?
+
+        user.update(telegram_id: nil)
+        send_message success_messages[:user_logged_out], msg.chat.id
+      rescue UserNotLoggedInError => e
+        send_message e.message, msg.chat.id
       end
 
       def new_chat_event
-        return not_logged_in_message unless user
+        raise UserNotLoggedInError if user.nil?
 
-        telegram_create_chat
+        NewChatJob.perform_async(msg.text.split("/").last, user.id, msg.chat.id)
+      rescue UserNotLoggedInError => e
+        send_message e.message, msg.chat.id
       end
 
       def select_chat_event
-        return not_logged_in_message unless user
+        raise UserNotLoggedInError if user.nil?
 
         title = msg.text.split("/").last
         chat = user.chat_by_title(title)
-        return chat_not_found_message unless chat
+        raise ChatNotFoundError if chat.nil?
 
-        user.update(current_chat_id: chat.id)
-        send_message success_messages[:chat_selected], msg.chat.id
-      end
+        raise ChatNotFoundError unless user.update(current_chat_id: chat.id)
 
-      def stop_event
-        send_message commom_messages[:stop], msg.chat.id
-        bot.api.leave_chat(chat_id: msg.chat.id)
-      end
-
-      def nil_event
-        send_message error_messages[:nil], msg.chat.id
+        send_message success_messages[:chat_selected], msg.chat.id
+      rescue UserNotLoggedInError, ChatNotFoundError => e
+        send_message e.message, msg.chat.id
       end
 
       def audio_event
-        return not_logged_in_message unless user
-        return no_chat_selected_message if user.current_chat_id.nil?
+        raise UserNotLoggedInError if user.nil?
+        raise NoChatSelectedError if user.current_chat.nil?
 
         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
+        raise MessageNotSavedError unless 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]
+      rescue UserNotLoggedInError, NoChatSelectedError, MessageNotSavedError => e
+        send_message e.message, msg.chat.id
       end
   end
 end

data/lib/chatgpt_assistant/config.rb

@@ -44,9 +44,25 @@ module ChatgptAssistant
       ActiveRecord::Base.logger = Logger.new($stdout) if ENV["ENV_TYPE"] == "development"
     end
 
+    def create_db
+      db_connection
+      return if database_exists?
+
+      ActiveRecord::Base.establish_connection(
+        adapter: "postgresql",
+        host: database_host,
+        port: 5432,
+        database: "postgres",
+        username: database_username,
+        password: database_password
+      )
+      ActiveRecord::Base.logger = Logger.new($stdout) if ENV["ENV_TYPE"] == "development"
+      ActiveRecord::Base.connection.create_database(database_name)
+    end
+
     def migrate
       db_connection
-      ActiveRecord::Base.logger = Logger.new($stdout)
+      ActiveRecord::Base.logger = Logger.new($stdout) if ENV["ENV_TYPE"] == "development"
       VisitorMigration.new.migrate(:up)
       UserMigration.new.migrate(:up)
       ChatMigration.new.migrate(:up)
@@ -57,5 +73,11 @@ module ChatgptAssistant
     private
 
       attr_reader :database_host, :database_name, :database_username, :database_password
+
+      def database_exists?
+        ActiveRecord::Base.connection
+      rescue ActiveRecord::NoDatabaseError
+        false
+      end
   end
 end