chatgpt_assistant 0.1.5 → 0.1.6

data/lib/chatgpt_assistant/default_messages.rb

@@ -3,15 +3,15 @@
 module ChatgptAssistant
   # This class is responsible for storing the default messages
   class DefaultMessages
-    def initialize(language = "en")
+    def initialize(language = "en", _discord_prefix = "!")
       @language = language
       load_message_context
     end
 
-    attr_reader :language, :commom_messages, :success_messages, :error_messages, :help_messages
+    attr_reader :language, :common_messages, :success_messages, :error_messages, :help_messages
 
     def load_message_context
-      @commom_messages = send("commom_messages_#{language}")
+      @common_messages = send("common_messages_#{language}")
       @success_messages = send("success_messages_#{language}")
       @error_messages = send("error_messages_#{language}")
       @help_messages = send("help_messages_#{language}")
@@ -19,7 +19,7 @@ module ChatgptAssistant
 
     private
 
-      def commom_messages_pt
+      def common_messages_pt
         {
           start: "Olá, eu sou o Chatgpt Assistant, um chatbot que usa a API da OpenAI para responder suas perguntas no Telegram e Discord.",
           stop: "Até mais!",
@@ -42,6 +42,7 @@ module ChatgptAssistant
           chat_created: "Chat criado com sucesso!",
           chat_selected: "Chat selecionado com sucesso!",
           user_logged_in: "Login realizado com sucesso!",
+          user_logged_out: "Logout realizado com sucesso!",
           voice_channel_connected: "O bot entrou no canal de voz com sucesso!"
         }
       end
@@ -49,26 +50,34 @@ module ChatgptAssistant
       def error_messages_pt
         {
           nil: "Não entendi o que você disse. Tente novamente",
-          email: "O email que você digitou não é válido. Tente novamente",
-          password: "A senha que você digitou não é válida. Tente novamente",
+          wrong_email: "O email que você digitou não é válido. Tente novamente",
           wrong_password: "A senha que você digitou não é válida. Tente novamente",
-          user: "O usuário que você digitou não existe. Tente novamente",
-          user_creation: "Erro ao criar usuário. Tente novamente",
+
           user_already_exists: "O usuário que você digitou já existe. Tente novamente",
-          chat_creation: "Erro ao criar chat. Tente novamente",
-          no_messages_founded: "Nenhuma mensagem encontrada",
+          chat_already_exists: "Você já possui um chat com este titulo. Tente novamente",
+
+          no_register_info: "Você não digitou o email e a senha. Tente novamente",
+          sign_up_error: "Erro ao criar usuário. Tente novamente",
+          chat_not_created_error: "Erro ao criar chat. Tente novamente",
+          message_not_created_error: "Erro ao criar mensagem. Tente novamente",
           no_chat_selected: "Nenhum chat selecionado",
-          chat_not_found: "Chat não encontrado",
+
+          no_messages_founded: "Nenhuma mensagem encontrada",
           no_chats_founded: "Nenhum chat encontrado",
+          chat_not_found: "Chat não encontrado",
+          user_not_found: "O usuário que você digitou não existe. Tente novamente",
+          user_not_registered: "O usuário não está registrado no sistema",
+          user_logged_in: "Usuário está logado no sistema, faça logout para continuar",
           user_not_logged_in: "Usuário não logado",
-          user_not_found: "Usuário não encontrado",
-          something_went_wrong: "Algo deu errado. Tente novamente mais tarde.",
-          message_history_too_long: "O histórico mensagem é muito longo.",
-          text_length: "O texto de resposta é muito longo. Tente diminuir a quantidade de respostas na mesma mensagem.",
+
           user_not_in_voice_channel: "Você não está em um canal de voz.",
           bot_not_in_voice_channel: "O bot não está em um canal de voz.",
+
+          message_history_too_long: "O histórico mensagem é muito longo.",
+          text_length_too_long: "O texto de resposta é muito longo. Tente diminuir a quantidade de respostas na mesma mensagem.",
+
           invalid_command: "Comando inválido. Tente novamente.",
-          message_creation_error: "Erro ao criar mensagem. Tente novamente."
+          something_went_wrong: "Algo deu errado. Tente novamente mais tarde."
         }
       end
 
@@ -83,7 +92,18 @@ module ChatgptAssistant
          "Para ver esta mensagem novamente, digite /help"]
       end
 
-      def commom_messages_en
+      def help_message_discord_pt
+        ["Para começar a conversar comigo, digite #{discord_prefix}start",
+         "Para parar de conversar comigo, digite #{discord_prefix}stop",
+         "Para se registrar no sistema, digite #{discord_prefix}register email:senha (a senha deve ser um numero de 4 digitos ex: 1234)",
+         "Para fazer login no sistema, digite #{discord_prefix}login email:senha (a senha deve ser um numero de 4 digitos ex: 1234)",
+         "Para criar um novo chat, digite #{discord_prefix}new_chat nome do chat",
+         "Para selecionar um chat, digite #{discord_prefix}sl_chat nome do chat",
+         "Para listar os chats que você criou, digite #{discord_prefix}list",
+         "Para ver esta mensagem novamente, digite #{discord_prefix}help"]
+      end
+
+      def common_messages_en
         {
           start: "Hello, I'm the Chatgpt Assistant, a chatbot that uses the OpenAI API to answer your questions on Telegram and Discord.",
           stop: "See you later!",
@@ -105,32 +125,43 @@ module ChatgptAssistant
           user_created: "User created successfully!",
           chat_created: "Chat created successfully!",
           chat_selected: "Chat selected successfully!",
-          user_logged_in: "Login successfully!"
+          user_logged_in: "Login successfully!",
+          user_logged_out: "Logout successfully!",
+          voice_channel_connected: "The bot entered the voice channel successfully!"
         }
       end
 
       def error_messages_en
         {
-          nil: "I didn't understand what you said. Try again",
-          email: "The email you typed is not valid. Try again",
-          password: "The password you typed is not valid. Try again",
+          nil: "I don't understand what you said. Try again",
+          wrong_email: "The email you typed is not valid. Try again",
           wrong_password: "The password you typed is not valid. Try again",
-          user: "The user you typed does not exist. Try again",
-          user_creation: "Error creating user. Try again",
-          chat_creation: "Error creating chat. Try again",
-          no_messages_founded: "No messages found",
+
+          user_already_exists: "The user you typed already exists. Try again",
+          chat_already_exists: "You already have a chat with this title. Try again",
+
+          no_register_info: "You did not type the email and password. Try again",
+          sign_up_error: "Error creating user. Try again",
+          chat_not_created_error: "Error creating chat. Try again",
+          message_not_created_error: "Error creating message. Try again",
           no_chat_selected: "No chat selected",
+
+          no_messages_founded: "No messages found",
           no_chats_founded: "No chats found",
           chat_not_found: "Chat not found",
+          user_not_found: "The user you typed does not exist. Try again",
+          user_not_registered: "The user is not registered in the system",
+          user_logged_in: "User is logged in the system, do logout to continue",
           user_not_logged_in: "User not logged in",
-          user_not_found: "User not found",
-          something_went_wrong: "Something went wrong. Try again later.",
-          message_history_too_long: "The message history is too long.",
-          text_length: "The response text is too long. Try to reduce the number of answers in the same message.",
+
           user_not_in_voice_channel: "You are not in a voice channel.",
           bot_not_in_voice_channel: "The bot is not in a voice channel.",
+
+          message_history_too_long: "The message history is too long.",
+          text_length_too_long: "The response text is too long. Try to reduce the number of responses in the same message.",
+
           invalid_command: "Invalid command. Try again.",
-          message_creation_error: "Error creating message. Try again."
+          something_went_wrong: "Something went wrong. Try again later."
         }
       end
 
@@ -144,5 +175,16 @@ module ChatgptAssistant
          "To list the chats you created, type /list",
          "To see this message again, type /help"]
       end
+
+      def help_message_discord_en
+        ["To start talking to me, type #{discord_prefix}start",
+         "To stop talking to me, type #{discord_prefix}stop",
+         "To register in the system, type #{discord_prefix}register email:password (the password must be a 4 digit number ex: 1234)",
+         "To log in to the system, type #{discord_prefix}login email:password (the password must be a 4 digit number ex: 1234)",
+         "To create a new chat, type #{discord_prefix}new_chat chat name",
+         "To select a chat, type #{discord_prefix}sl_chat chat name",
+         "To list the chats you created, type #{discord_prefix}list",
+         "To see this message again, type #{discord_prefix}help"]
+      end
   end
 end

data/lib/chatgpt_assistant/error.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Load Error
+  module LoadError
+    def load_error_context
+      language = ENV.fetch("LANGUAGE", "en")
+      discord_prefix = ENV.fetch("DISCORD_PREFIX", "!")
+      DefaultMessages.new(language, discord_prefix).error_messages
+    end
+  end
+
+  # No User Error
+  class NoRegisterInfoError < StandardError
+    def initialize(message = load_error_context[:no_register_info])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Nil Command Error
+  class NilError < StandardError
+    def initialize(message = load_error_context[:nil])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Wrong Email Error
+  class WrongEmailError < StandardError
+    def initialize(message = load_error_context[:wrong_email])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Wrong Password Error
+  class WrongPasswordError < StandardError
+    def initialize(message = load_error_context[:wrong_password])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Already Exists Error
+  class UserAlreadyExistsError < StandardError
+    def initialize(message = load_error_context[:user_already_exists])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Chat Already Exists Error
+  class ChatAlreadyExistsError < StandardError
+    def initialize(message = load_error_context[:chat_already_exists])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Sign Up Error
+  class SignUpError < StandardError
+    def initialize(message = load_error_context[:sign_up_error])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Chat Not Created Error
+  class ChatNotCreatedError < StandardError
+    def initialize(message = load_error_context[:chat_not_created_error])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Message Not Created Error
+  class MessageNotCreatedError < StandardError
+    def initialize(message = load_error_context[:message_not_created_error])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # No Chat Selected Error
+  class NoChatSelectedError < StandardError
+    def initialize(message = load_error_context[:no_chat_selected])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # No Messages Founded Error
+  class NoMessagesFoundedError < StandardError
+    def initialize(message = load_error_context[:no_messages_founded])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # No Chats Founded Error
+  class NoChatsFoundedError < StandardError
+    def initialize(message = load_error_context[:no_chats_founded])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Chat Not Found Error
+  class ChatNotFoundError < StandardError
+    def initialize(message = load_error_context[:chat_not_found])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not Found Error
+  class UserNotFoundError < StandardError
+    def initialize(message = load_error_context[:user_not_found])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not Registered Error
+  class UserNotRegisteredError < StandardError
+    def initialize(message = load_error_context[:user_not_registered])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Logged In Error
+  class UserLoggedInError < StandardError
+    def initialize(message = load_error_context[:user_logged_in])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not Logged In Error
+  class UserNotLoggedInError < StandardError
+    def initialize(message = load_error_context[:user_not_logged_in])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not In Voice Channel Error
+  class UserNotInVoiceChannelError < StandardError
+    def initialize(message = load_error_context[:user_not_in_voice_channel])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Bot Not In Voice Channel Error
+  class BotNotInVoiceChannelError < StandardError
+    def initialize(message = load_error_context[:bot_not_in_voice_channel])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Message Not Found Error
+  class MessageHistoryTooLongError < StandardError
+    def initialize(message = load_error_context[:message_history_too_long])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Text Length Too Long Error
+  class TextLengthTooLongError < StandardError
+    def initialize(message = load_error_context[:text_length_too_long])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Invalid Command Error
+  class InvalidCommandError < StandardError
+    def initialize(message = load_error_context[:invalid_command])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Something Went Wrong Error
+  class SomethingWentWrongError < StandardError
+    def initialize(message = load_error_context[:something_went_wrong])
+      super(message)
+    end
+
+    include LoadError
+  end
+end

data/lib/chatgpt_assistant/models.rb

@@ -5,8 +5,6 @@ require "active_record"
 # Visitor model
 class Visitor < ActiveRecord::Base
   has_many :visitor_actions
-  # has_one :tel_user, foreign_key: "telegram_id", class_name: "User"
-  # has_one :dis_user, foreign_key: "discord_id", class_name: "User"
   validates :name, presence: true
   validates :platform, presence: true
   enum platform: { telegram: 0, discord: 1 }
@@ -26,19 +24,23 @@ class User < ActiveRecord::Base
 
   belongs_to :tel_visitor, optional: true, foreign_key: "telegram_id", class_name: "Visitor"
   belongs_to :dis_visitor, optional: true, foreign_key: "discord_id", class_name: "Visitor"
-  before_save :encrypt_password
-  validates :email, presence: true, uniqueness: true
-  validates :role, presence: true
-  validates :open_chats, presence: true
-  validates :closed_chats, presence: true
-  validates :total_chats, presence: true
-  validates :total_messages, presence: true
+
+  validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }, length: { maximum: 100 }, on: :create
+  validates :role, presence: true, on: :create
+  validates :open_chats, presence: true, on: :create
+  validates :closed_chats, presence: true, on: :create
+  validates :total_chats, presence: true, on: :create
+  validates :total_messages, presence: true, on: :create
+  validates :password, presence: true, on: :create
+
+  before_save :encrypt_password, if: :password
+
   has_many :chats
 
   def encrypt_password
     return if password.nil?
 
-    self.password_salt = BCrypt::Engine.generate_salt.to_s
+    self.password_salt = BCrypt::Engine.generate_salt
     self.password_hash = BCrypt::Engine.hash_secret(password, password_salt)
   end
 
@@ -53,6 +55,10 @@ class User < ActiveRecord::Base
   def chat_by_title(title)
     chats.find_by(title: title)
   end
+
+  def chat_history
+    current_chat.messages.last(10).map { |m| "#{m.role}: #{m.content}\nat: #{m.created_at}" }
+  end
 end
 
 # Chat model
@@ -69,15 +75,14 @@ class Chat < ActiveRecord::Base
   def init_chat_if_actor_provided
     return if actor.nil?
 
-    messages.create(content: prompt, role: "user")
-    messages.create(content: "Hello, I'm #{actor}. I will follow #{prompt}", role: "assistant")
+    messages.create(content: prompt, role: "system")
   end
 end
 
 # Message model
 class Message < ActiveRecord::Base
   validates :content, presence: true
-  enum role: { user: 0, assistant: 1 }
+  enum role: { user: 0, assistant: 1, system: 2 }
 
   belongs_to :chat
 end

data/lib/chatgpt_assistant/sidekiq.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "../chatgpt_assistant"
+
+Sidekiq.configure_server do |config|
+  config.redis = { url: ENV.fetch("REDIS_URL", "redis://redis:6379/1") }
+end

data/lib/chatgpt_assistant/sidekiq.yml

@@ -0,0 +1,10 @@
+development:
+  :concurrency: 5
+
+production:
+  :concurrency: 5
+
+:max_retries: 1
+
+:queues:
+  - default

data/lib/chatgpt_assistant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChatgptAssistant
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/lib/chatgpt_assistant.rb

@@ -7,6 +7,7 @@ require_relative "chatgpt_assistant/chatter"
 require_relative "chatgpt_assistant/version"
 require_relative "chatgpt_assistant/config"
 require_relative "chatgpt_assistant/models"
+require_relative "chatgpt_assistant/error"
 require_relative "bots/application_bot"
 require_relative "bots/telegram_bot"
 require_relative "bots/discord_bot"
@@ -16,6 +17,8 @@ require "aws-sdk-polly"
 require "telegram/bot"
 require "ibm_watson"
 require "discordrb"
+require "sidekiq"
+require "sidekiq-scheduler"
 require "faraday"
 require "bcrypt"
 
@@ -32,24 +35,12 @@ module ChatgptAssistant
       return discord_bot if discord_mode?
 
       raise "Invalid mode"
-    rescue StandardError => e
-      save_error(e)
-      retry
     end
 
     private
 
       attr_reader :mode, :config
 
-      def save_error(err)
-        puts "Error: #{err.message}"
-        err.backtrace.each { |line| puts line }
-        Error.create(message: err.message, backtrace: err.backtrace) unless err.message == Error.last&.message
-      rescue StandardError
-        puts "Error: #{err.message}"
-        puts "Backtrace: #{err.backtrace}"
-      end
-
       def telegram_mode?
         mode == "telegram"
       end