chatgpt_assistant 0.1.5 → 0.1.7

data/lib/chatgpt_assistant/bots/telegram/permissions.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module Permissions
+        def hist_allowed?
+          raise UserNotLoggedInError if user.nil?
+          raise AccountNotVerifiedError unless user.active?
+          raise NoChatSelectedError if user.current_chat.nil?
+          raise NoMessagesFoundedError if user.current_chat.messages.count.zero?
+        end
+
+        def list_allowed?
+          raise UserNotLoggedInError if user.nil?
+          raise AccountNotVerifiedError unless user.active?
+          raise NoChatsFoundedError if user.chats.count.zero?
+        end
+
+        def register_allowed?(user_info)
+          raise NoRegisterInfoError if user_info.nil?
+          raise UserLoggedInError if user
+
+          email, password = user_info.split(":")
+          raise NoRegisterEmailError if email.nil? || password.nil?
+
+          [email, password]
+        end
+
+        def common_allowed?
+          raise UserNotLoggedInError if user.nil?
+          raise AccountNotVerifiedError unless user.active?
+        end
+
+        def select_allowed?(chat)
+          raise ChatNotFoundError if chat.nil?
+          raise ChatNotFoundError unless user.update(current_chat_id: chat.id)
+        end
+
+        def audio_allowed?
+          raise UserNotLoggedInError if user.nil?
+          raise AccountNotVerifiedError unless user.active?
+          raise NoChatSelectedError if user.current_chat.nil?
+        end
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/telegram/validations.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module Validations
+        def telegram_actions?
+          msg.text.include?("new_chat/") || msg.text.include?("sl_chat/") || msg.text.include?("login/") || msg.text.include?("register/")
+        end
+
+        def telegram_text_or_audio?
+          msg.respond_to?(:text) || msg.respond_to?(:audio) || msg.respond_to?(:voice)
+        end
+
+        def telegram_message_has_text?
+          msg.text.present?
+        end
+
+        def telegram_message_has_audio?
+          msg.audio.present? || msg.voice.present?
+        end
+
+        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)
+          else
+            visitor
+          end
+        end
+
+        def visitor_user?
+          visitor&.tel_user.nil?
+        end
+
+        def valid_for_list_action?
+          send_message(chat_id: msg.chat.id, text: error_messages[:user_not_logged_in]) if user.nil?
+          send_message(chat_id: msg.chat.id, text: error_messages[:account_not_verified]) unless user.active?
+          send_message(chat_id: msg.chat.id, text: error_messages[:chat_not_found]) if user.chats.count.zero? && user.active?
+          !user.nil? && user.active? && user.chats.count.positive?
+        end
+
+        def auth_event?
+          msg.text.include?("login/") || msg.text.include?("register/") || msg.text.include?("sign_out/") || msg.text.include?("confirm/* ")
+        end
+
+        def user_confirmed?
+          user.name == name && user.confirm_account(token)
+        end
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/telegram/voice_actions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module VoiceActions
+        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
+  end
+end

data/lib/chatgpt_assistant/bots/telegram_bot.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "telegram/bot"
+require_relative "telegram/auth"
+require_relative "telegram/actions"
+require_relative "telegram/events"
+require_relative "telegram/chat_actions"
+require_relative "telegram/validations"
+require_relative "telegram/voice_actions"
+require_relative "telegram/permissions"
+require_relative "telegram/events_controller"
+
+module ChatgptAssistant
+  # This class is responsible for the telegram bot features
+  class TelegramBot < ApplicationBot
+    def start
+      bot.listen do |message|
+        @msg = message
+        @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 => e
+      Error.create(message: e.message, backtrace: e.backtrace)
+      retry
+    end
+
+    private
+
+      attr_accessor :msg, :visitor, :chat, :chat_id
+
+      include Bots::Telegram::Bot
+      include Bots::Telegram::Auth
+      include Bots::Telegram::Actions
+      include Bots::Telegram::Events
+      include Bots::Telegram::ChatActions
+      include Bots::Telegram::Validations
+      include Bots::Telegram::VoiceActions
+      include Bots::Telegram::Permissions
+      include Bots::Telegram::EventsController
+  end
+end

data/lib/chatgpt_assistant/chatter.rb

@@ -17,7 +17,7 @@ module ChatgptAssistant
       @response = request(message)
       @json = JSON.parse(response.body)
 
-      return no_response_error if json["choices"].empty?
+      return no_response_error if json["choices"] && json["choices"].empty?
       return bot_offline_error if response.status != 200
 
       text = json["choices"][0]["message"]["content"]
@@ -57,7 +57,8 @@ module ChatgptAssistant
       end
 
       def request_params(message)
-        messages = Message.where(chat_id: chat_id).order(id: :asc).last(10)
+        messages_from_chat = Message.where(chat_id: chat_id)
+        messages = messages_from_chat.order(id: :asc).last(10)
         messages = if messages.empty?
                      [{ role: "user", content: message }]
                    else
@@ -66,6 +67,13 @@ module ChatgptAssistant
                          content: mess.content }
                      end
                    end
+
+        first_message = messages_from_chat.order(id: :asc).first
+        system_message = first_message if first_message&.role == "system"
+        if system_message && Message.where(chat_id: chat_id).count > 10
+          messages.unshift({ role: system_message.role,
+                             content: system_message.content })
+        end
         {
           model: "gpt-3.5-turbo",
           messages: messages,

data/lib/chatgpt_assistant/config.rb

@@ -2,6 +2,7 @@
 
 require "active_record"
 require "active_model"
+require "action_mailer"
 require_relative "migrations"
 require "fileutils"
 
@@ -30,7 +31,9 @@ module ChatgptAssistant
 
     attr_reader :openai_api_key, :telegram_token, :discord_token, :ibm_api_key, :ibm_url,
                 :aws_access_key_id, :aws_secret_access_key, :aws_region, :mode, :language,
-                :discord_client_id, :discord_public_key, :env_type, :discord_prefix
+                :discord_client_id, :discord_public_key, :env_type, :discord_prefix,
+                :smtp_address, :smtp_port, :smtp_domain, :smtp_user_name, :smtp_password,
+                :smtp_authentication, :smtp_enable_starttls_auto
 
     def db_connection
       ActiveRecord::Base.establish_connection(
@@ -44,9 +47,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 +76,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

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,33 +42,45 @@ module ChatgptAssistant
           chat_created: "Chat criado com sucesso!",
           chat_selected: "Chat selecionado com sucesso!",
           user_logged_in: "Login realizado com sucesso!",
-          voice_channel_connected: "O bot entrou no canal de voz com sucesso!"
+          user_logged_out: "Logout realizado com sucesso!",
+          voice_channel_connected: "O bot entrou no canal de voz com sucesso!",
+          account_confirmed: "Conta confirmada com sucesso!"
         }
       end
 
       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.",
+          account_not_verified: "Sua conta não foi verificada. Verifique sua caixa de email.",
+          account_not_confirmed: "Sua conta não foi confirmada. Verifique sua caixa de email."
         }
       end
 
@@ -83,7 +95,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 +128,46 @@ 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!",
+          account_confirmed: "Your account has been verified!"
         }
       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.",
+          account_not_verified: "Your account is not verified. Please check your email and verify your account.",
+          account_not_confirmed: "Something went wrong. Please check your email and verify your account. Maybe you pass the wrong code."
         }
       end
 
@@ -144,5 +181,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,228 @@
+# 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
+
+  # Account Not Verified Error
+  class AccountNotVerifiedError < StandardError
+    def initialize(message = load_error_context[:account_not_verified])
+      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