chatgpt_assistant 0.1.4 → 0.1.6

data/lib/bots/helpers/authentication_helper.rb

@@ -23,7 +23,8 @@ module ChatgptAssistant
 
     def telegram_user_access(visitor, new_access)
       other_access = where_user(telegram_id: visitor.telegram_id)
-      other_access&.each { |access| access.update(telegram_id: nil) }
+      other_access&.each { |access| access.update(telegram_id: nil) } if other_access&.class == Array
+      other_access&.update(telegram_id: nil) if other_access&.class == User
       new_access.update(telegram_id: visitor.telegram_id)
       new_access.email
     end
@@ -37,11 +38,11 @@ module ChatgptAssistant
     end
 
     def discord_user_access(discord_id, user_email)
-      last_access = find_user(discord_id: discord_id)
-      new_access = find_user(email: user_email)
-      last_acess.update(discord_id: nil) if last_access&.email != new_access&.email
-      new_access&.update(discord_id: discord_id)
-      new_access.email
+      other_access = where_user(discord_id: discord_id)
+      other_access&.each { |access| access.update(discord_id: nil) }
+      user = find_user(email: user_email)
+      user.update(discord_id: discord_id)
+      user.email
     end
   end
 end

data/lib/bots/helpers/discord_helper.rb

@@ -12,8 +12,8 @@ module ChatgptAssistant
     end
 
     def start_action
-      send_message commom_messages[:start_helper].gsub("register/", "gpt!register ")
-      send_message commom_messages[:start_sec_helper].gsub("login/", "gpt!login ")
+      send_message common_messages[:start_helper].gsub("register/", "gpt!register ")
+      send_message common_messages[:start_sec_helper].gsub("login/", "gpt!login ")
     end
 
     def login_action
@@ -46,7 +46,7 @@ module ChatgptAssistant
 
     def list_action
       chats_title = user.chats.map(&:title)
-      send_message commom_messages[:chat_list]
+      send_message common_messages[:chat_list]
       send_message chats_title.join("\n")
     end
 
@@ -68,6 +68,13 @@ module ChatgptAssistant
       (message.save ? answer_action : send_message(error_messages[:message_not_saved])) if chat
     end
 
+    def private_message_action
+      @chat = Chat.where(id: user.current_chat_id).last
+      send_message error_messages[:chat_not_found] if chat.nil?
+      @message = Message.new(chat_id: chat.id, content: message, role: "user") if chat
+      (message.save ? answer_action : send_message(error_messages[:message_not_saved])) if chat
+    end
+
     def sl_chat_action(chat_to_select)
       @chat = user.chat_by_title(chat_to_select)
       send_message error_messages[:chat_not_found] if chat.nil?
@@ -76,13 +83,28 @@ module ChatgptAssistant
     end
 
     def create_chat_action
-      chat_title = evnt.message.content.split[1..].join(" ")
-      @chat = Chat.new(user_id: user.id, title: chat_title, status: 0)
-      chat.save ? respond_with_success : send_message(error_messages[:chat_creation])
+      title = evnt.message.content.split[1..].join(" ")
+      mode = nil
+      if title.include? ":"
+        mode = title.split(":").last.to_i
+        title = title.split(":").first
+      end
+      actors = AwesomeChatgptActors::CastControl.actors
+      return send_message "invalid mode" unless (mode.to_i >= 1 && mode.to_i <= actors.size + 1) || mode.nil?
+      return send_message "invalid chat title" if title.nil? || title.empty?
+      return send_message "chat title already exists" if user.chat_by_title(title)
+
+      actor_name = actors[mode.to_i - 1] if mode
+      actor = AwesomeChatgptActors::Actor.new(role: actor_name, language: config.language) if actor_name
+      chat = Chat.new(user_id: user.id, status: 0, title: title, actor: actor_name, prompt: actor.prompt) if actor
+      chat = Chat.new(user_id: user.id, status: 0, title: title) unless actor
+      return send_message "Something went wrong", msg.chat.id unless chat
+
+      chat.save ? chat_created_message(chat) : send_message(error_messages[:chat_creation])
     end
 
     def answer_action
-      response = chatter.chat(message.content, chat.id)
+      response = chatter.chat(message.content, chat.id, error_messages[:something_went_wrong])
       send_message response
     end
 

data/lib/bots/helpers/discord_voice_helper.rb

@@ -25,7 +25,7 @@ module ChatgptAssistant
 
     def ask_to_speak_action
       Message.create(chat_id: chat.id, content: message, role: "user")
-      response = chatter.chat(message, chat.id)
+      response = chatter.chat(message, chat.id, error_messages[:something_went_wrong])
       audio_path = synthesis.synthesize_text(response)
       speak_answer_action(audio_path, response)
     end

data/lib/bots/helpers/messenger_helper.rb

@@ -4,13 +4,17 @@ module ChatgptAssistant
   # Helper for messenger
   module MessengerHelper
     def chat_success(chat_id)
-      Message.create(chat_id: chat_id, content: msg.text, role: "user")
-      text = chatter.chat(msg.text, chat_id)
-      mess = parse_message(text, 4096)
-      mess.each { |m| send_message m, msg.chat.id }
+      user_message = Message.new(chat_id: chat_id, content: msg.text, role: "user")
+      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 }
+      else
+        send_message error_messages[:something_went_wrong], msg.chat.id
+      end
     end
 
-    def respond_with_success
+    def respond_with_success(chat)
       user.update(current_chat_id: chat.id)
       send_message success_messages[:chat_created]
     end
@@ -48,86 +52,81 @@ module ChatgptAssistant
     end
 
     def user_logged_message
-      register_user_action("login", user.id)
       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
-      register_user_action("invalid_command", user.id) if user
-      register_visitor_action("invalid_command", visitor.id) if visitor&.tel_user.nil?
-      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
-      register_visitor_action("error: user not found", visitor.id)
-      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
-      register_visitor_action("user_created", visitor.id)
-      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
-      register_visitor_action("error: user creation", visitor.id)
-      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
 
     def chat_created_message(chat)
-      register_user_action("chat_created", user.id) if user
       user&.update(current_chat_id: chat.id)
-      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:chat_created]) if bot.api.present?
+      return telegram_created(chat) if bot.respond_to?(:api)
+
+      discord_created(chat)
+    end
+
+    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.respond_to?(:api)
+    end
+
+    def discord_created(chat)
+      evnt.respond "Intructions sended to actor:\n#{chat.prompt}" unless chat.actor.nil?
+      evnt.respond success_messages[:chat_created] if evnt.present?
     end
 
     def not_logged_in_message
-      register_visitor_action("error: not logged in", visitor.id) if visitor_user?
-      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
-      register_visitor_action("error: wrong password", visitor.id) if visitor_user?
-      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
-      register_visitor_action("error: visitors cant select chat", visitor.id) if visitor_user?
-      register_user_action("error: chat not found", user.id) if user
-      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
-      register_visitor_action("error: visitors cant select chat", visitor.id) if visitor_user?
-      register_user_action("error: no chat selected", user.id) if user
-      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
-      register_visitor_action("error: visitors cant view the chat history", visitor.id) if visitor_user?
-      register_user_action("error: no messages founded", user.id) if user
-      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
-      register_visitor_action("error: chat creation failed", visitor.id) if visitor_user?
-      register_user_action("error: chat creation failed", user.id) if user
-      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
-      register_visitor_action("user_logged_in", visitor.id) if visitor
-      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

@@ -15,33 +15,6 @@ module ChatgptAssistant
       user ? chat_if_exists : not_logged_in_message
     end
 
-    def telegram_audio_info
-      bot.api.get_file(file_id: telegram_audio.file_id)
-    end
-
-    def telegram_audio_url
-      "https://api.telegram.org/file/bot#{telegram_token}/#{telegram_audio_info["result"]["file_path"]}"
-    end
-
-    def telegram_audio
-      msg.audio || msg.voice
-    end
-
-    def telegram_process_ai_voice(user_audio)
-      ai_text = chatter.chat(user_audio["text"], user.current_chat_id)
-      ai_voice = synthesis.synthesize_text(ai_text)
-      {
-        voice: ai_voice,
-        text: ai_text
-      }
-    end
-
-    def telegram_send_voice_message(voice: nil, text: nil)
-      messages = parse_message text, 4096
-      bot.api.send_voice(chat_id: msg.chat.id, voice: Faraday::UploadIO.new(voice, "audio/mp3"))
-      messages.each { |message| send_message message, msg.chat.id }
-    end
-
     def telegram_user_create(visitor_id, email, password)
       visitor = Visitor.find_by(id: visitor_id)
       return false unless visitor
@@ -52,22 +25,33 @@ 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
       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
+      mode = nil
+      if title.include?(":")
+        mode = title.split(":").last
+        title = title.split(":").first
+      end
+      actor_modes = AwesomeChatgptActors::CastControl.actors
+      return send_message "invalid mode", msg.chat.id unless (mode.to_i >= 1 && mode.to_i <= actor_modes.size + 1) || mode.nil?
+      return send_message "invalid chat title", msg.chat.id if title.nil? || title.empty?
+      return send_message "You already have a chat with this title", msg.chat.id if user.chat_by_title(title)
+
+      actor_name = actor_modes[mode.to_i - 1] if mode
+      actor = AwesomeChatgptActors::Actor.new(prompt_type: actor_name) if actor_name
+      chat = Chat.new(user_id: user.id, status: 0, title: title, actor: actor_name, prompt: actor.prompt) if actor
+      chat = Chat.new(user_id: user.id, status: 0, title: title) unless actor
+      return send_message "Something went wrong", msg.chat.id unless chat
 
-    def telegram_user_history
-      user.current_chat.messages.last(10).map { |m| "#{m.role}: #{m.content}\nat: #{m.created_at}" }
+      chat.save ? chat_created_message(chat) : chat_creation_failed_message
     end
 
     def telegram_text_or_audio?

data/lib/bots/helpers/telegram_voice_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Telegram Voice Helper
+  module TelegramVoiceHelper
+    def telegram_audio_info
+      bot.api.get_file(file_id: telegram_audio.file_id)
+    end
+
+    def telegram_audio_url
+      "https://api.telegram.org/file/bot#{telegram_token}/#{telegram_audio_info["result"]["file_path"]}"
+    end
+
+    def telegram_audio
+      msg.audio || msg.voice
+    end
+
+    def telegram_process_ai_voice(user_audio)
+      ai_text = chatter.chat(user_audio["text"], user.current_chat_id, error_messages[:something_went_wrong])
+      ai_voice = synthesis.synthesize_text(ai_text)
+      {
+        voice: ai_voice,
+        text: ai_text
+      }
+    end
+
+    def telegram_send_voice_message(voice: nil, text: nil)
+      messages = parse_message text, 4096
+      bot.api.send_voice(chat_id: msg.chat.id, voice: Faraday::UploadIO.new(voice, "audio/mp3"))
+      messages.each { |message| send_message message, msg.chat.id }
+    end
+  end
+end

data/lib/bots/helpers/validation_helper.rb

@@ -25,5 +25,14 @@ module ChatgptAssistant
     def discord_voice_bot_connected?
       user && evnt.user.voice_channel && evnt.voice && !chat.nil?
     end
+
+    def discord_next_action?
+      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}")
+      end
+      false
+    end
   end
 end

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