chatgpt_assistant 0.1.5 → 0.1.7

data/lib/chatgpt_assistant/bots/discord/voice_checkers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module VoiceCheckers
+        def voice_connect_checker_action
+          send_message error_messages[:user_not_logged_in] if user.nil?
+          send_message error_messages[:chat_not_found] if user && chat.nil?
+        end
+
+        def voice_connection_checker_action
+          send_message error_messages[:user_not_in_voice_channel] if evnt.user.voice_channel.nil? && user
+          send_message error_messages[:bot_already_connected] if evnt.voice && user
+        end
+
+        def speak_connect_checker_action
+          send_message error_messages[:user_not_logged_in] if user.nil?
+          send_message error_messages[:chat_not_found] if user && evnt.user.voice_channel && evnt.voice && chat.nil?
+        end
+
+        def speak_connection_checker_action
+          send_message error_messages[:user_not_in_voice_channel] if evnt.user.voice_channel.nil? && user
+          send_message error_messages[:bot_not_in_voice_channel] if !evnt.voice && user
+        end
+
+        def disconnect_checker_action
+          send_message error_messages[:user_not_logged_in] if user.nil?
+          send_message error_messages[:user_not_in_voice_channel] if evnt.user.voice_channel.nil? && user
+          send_message error_messages[:user_not_connected] if !evnt.voice && user
+        end
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/discord_bot.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "discord/bot"
+require_relative "discord/auth"
+require_relative "discord/actions"
+require_relative "discord/chat_actions"
+require_relative "discord/events"
+require_relative "discord/voice_actions"
+require_relative "discord/voice_checkers"
+
+module ChatgptAssistant
+  # This class is responsible to handle the discord bot
+  class DiscordBot < ApplicationBot
+    def start
+      start_event
+      login_event
+      list_event
+      hist_event
+      help_event
+      new_chat_event
+      sl_chat_event
+      ask_event
+      voice_connect_event
+      voice_disconnect_event
+      private_message_event
+      bot_init
+    end
+
+    private
+
+      attr_reader :message
+      attr_accessor :evnt, :user, :chats, :chat
+
+      include Bots::Discord::Bot
+      include Bots::Discord::Auth
+      include Bots::Discord::Actions
+      include Bots::Discord::ChatActions
+      include Bots::Discord::Events
+      include Bots::Discord::VoiceActions
+      include Bots::Discord::VoiceCheckers
+  end
+end

data/lib/chatgpt_assistant/bots/helpers/messenger_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for messenger
+  module MessengerHelper
+    def parse_message(message, max_length)
+      if message.length > max_length
+        array = message.scan(/.{1,#{max_length}}/) if max_length.positive?
+        array = ["Something went wrong! Try again later"] if max_length <= 0
+      else
+        array = [message]
+      end
+      array
+    end
+  end
+end

data/lib/{bots → chatgpt_assistant/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/chatgpt_assistant/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/chatgpt_assistant/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, name, chat_id)
+      RegisterService.new(email, password, name, chat_id).call
+    end
+  end
+end

data/lib/chatgpt_assistant/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/chatgpt_assistant/bots/mailers/account_mailer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "application_mailer"
+
+module ChatgptAssistant
+  # This class is responsible for the register mailer
+  class AccountMailer < ApplicationMailer
+    def register_email(user, token)
+      @user = user
+      @token = token
+      mail(to: user.email, subject: "Welcome to ChatGPT Assistant",
+           content_type: "text/html",
+           body: register_html)
+    end
+
+    private
+
+      attr_reader :user, :token
+
+      def register_html
+        "<h1>Welcome to ChatGPT Assistant</h1> \n
+        <p>Hi #{user.name}</p> \n
+        <p>You are now registered to ChatGPT Assistant</p> \n
+        <p>You can now start using the bot</p> \n
+        <p>To start using the bot, copy and paste the following link in TELEGRAM bot:</p> \n
+        <p>confirm/* #{user.name}:#{token}</p> \n
+        "
+      end
+  end
+end

data/lib/chatgpt_assistant/bots/mailers/application_mailer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Gem module
+module ChatgptAssistant
+  ActionMailer::Base.raise_delivery_errors = true
+  ActionMailer::Base.delivery_method = :smtp
+  ActionMailer::Base.smtp_settings = {
+    address: ENV.fetch("SMTP_ADDRESS", nil),
+    port: ENV.fetch("SMTP_PORT", nil),
+    domain: ENV.fetch("SMTP_DOMAIN", nil),
+    user_name: ENV.fetch("SMTP_USER_NAME", nil),
+    password: ENV.fetch("SMTP_PASSWORD", nil),
+    authentication: ENV.fetch("SMTP_AUTHENTICATION", nil),
+    enable_starttls_auto: ENV.fetch("SMTP_ENABLE_STARTTLS_AUTO", nil) == "true"
+  }
+
+  # This class is responsible for the application mailer
+  class ApplicationMailer < ActionMailer::Base
+    default from: "support@chat.outerspacecoding.com"
+  end
+end

data/lib/chatgpt_assistant/bots/services/new_chat_service.rb

@@ -0,0 +1,59 @@
+#  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 actors
+      @actors ||= AwesomeChatgptActors::CastControl.actors
+    end
+
+    def actor
+      @actor_name = actors[@actor_mode.to_i - 1] if @actor_mode
+      @actor = AwesomeChatgptActors::Actor.new(role: @actor_name, language: @config.language) if @actor_name
+    end
+
+    def chat
+      @chat = Chat.new(title: @chat_title, user_id: @user_id, status: 0, actor: @actor_name, prompt: @actor.prompt) if !@actor.nil? && @actor_name
+      @chat = Chat.new(title: @chat_title, user_id: @user_id, status: 0) unless @actor_name
+    end
+
+    def parse_title
+      return @chat_title.strip! unless @chat_title.include?("actor:")
+
+      @actor_mode = @chat_title.split("actor:")[1].strip
+      @chat_title = @chat_title.split("actor:")[0].strip
+    end
+
+    def call
+      raise NilError if @chat_title.nil?
+      raise NilError if @user_id.nil?
+      raise NilError if @chat_id.nil?
+
+      parse_title
+
+      raise InvalidModeError unless (@actor_mode.to_i >= 1 && @actor_mode.to_i <= actors.size + 1) || @actor_mode.nil?
+      raise InvalidChatTitleError if @chat_title.nil? || @chat_title.empty?
+      raise ChatAlreadyExistsError if Chat.find_by(title: @chat_title)
+
+      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/chatgpt_assistant/bots/services/register_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # This class is responsible to background the register service
+  class RegisterService
+    def initialize(email, password, name, chat_id)
+      @name = name
+      @email = email
+      @password = password
+      @chat_id = chat_id
+      @config = Config.new
+      @config.db_connection
+    end
+
+    def call
+      return if user_already_exists?
+
+      @user = User.new(email: @email, password: @password, telegram_id: @chat_id, name: @name)
+      @user.save ? success_message : error_message
+    rescue UserAlreadyExistsError, WrongEmailError, WrongPasswordError => e
+      telegram_async.send_message(e.message, @chat_id)
+    end
+
+    private
+
+      def telegram_async
+        TelegramBot.new(@config)
+      end
+
+      def success_message
+        confirmation_token = @user.encrypt_token
+        telegram_async.send_message("Registration successful! Check your email for confirmation.", @chat_id)
+        AccountMailer.register_email(@user, confirmation_token).deliver_now
+      end
+
+      def error_message
+        raise WrongEmailError if @user.errors[:email].any?
+        raise WrongPasswordError if @user.errors[:password].any?
+      end
+
+      def user_already_exists?
+        raise UserAlreadyExistsError if User.find_by(email: @email)
+      end
+  end
+end

data/lib/chatgpt_assistant/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/chatgpt_assistant/bots/telegram/actions.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module Actions
+        def telegram_user_create(visitor_id, email, password)
+          visitor = Visitor.find_by(id: visitor_id)
+          return false unless visitor
+
+          visitor.tel_user.update(telegram_id: nil) if visitor.tel_user.present?
+          user = User.new(telegram_id: visitor.telegram_id, email: email, password: password)
+          user.save ? user.email : user.errors.full_messages
+        end
+
+        def telegram_send_start_message
+          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 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
+          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
+
+          chat.save ? chat_created_message(chat) : send_message(chat_id: msg.chat.id, text: error_messages[:chat_creation_failed])
+        end
+
+        def chat_created_message(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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module Auth
+        def authenticate_user(email, password)
+          case telegram_user_auth(email, password, msg.chat.id)
+          when "user not found"
+            raise UserNotFoundError
+          when "wrong password"
+            raise WrongPasswordError
+          when email
+            send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in])
+          end
+        end
+
+        def telegram_user_auth(email, password, telegram_id)
+          return "wrong password" if password.nil?
+
+          visitor_access = find_visitor(telegram_id: telegram_id)
+          return "something went wrong" unless visitor_access
+
+          new_access = find_user(email: email)
+          return "user not found" unless new_access
+
+          user.valid_password?(password) ? telegram_user_access(visitor_access, new_access) : "wrong password"
+        end
+
+        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) } 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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module Bot
+        def bot
+          @bot ||= ::Telegram::Bot::Client.new(telegram_token, logger: Logger.new($stderr))
+        end
+
+        def user
+          @user = find_user(telegram_id: msg.chat.id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module ChatActions
+        def chat_if_exists
+          chat = Chat.find_by(user_id: user.id, id: user.current_chat_id)
+          chat ? chat_success(chat.id) : send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected])
+        end
+
+        def chat_success(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 send_message(text, chat_id)
+          messages = parse_message(text, 4096)
+          messages.each { |m| bot.api.send_message(chat_id: chat_id, text: m) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module Events
+        def start_event
+          telegram_send_start_message
+        end
+
+        def help_event
+          help_messages.each { |m| send_message m, msg.chat.id }
+        end
+
+        def hist_event
+          hist_allowed?
+
+          user.chat_history.each do |m|
+            send_message m, msg.chat.id
+          end
+        rescue NoChatSelectedError, UserNotLoggedInError, NoMessagesFoundedError, AccountNotVerifiedError => e
+          send_message e.message, msg.chat.id
+        end
+
+        def list_event
+          list_allowed?
+
+          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, AccountNotVerifiedError => e
+          send_message e.message, msg.chat.id
+        end
+
+        def confirm_account_event
+          raise UserNotLoggedInError if user.nil?
+
+          user_info = msg.text.split("/* ").last
+          name, token = user_info.split(":")
+          send_message "#{name} - #{token}", msg.chat.id
+          if user_confirmed?
+            send_message success_messages[:account_confirmed], msg.chat.id
+          else
+            send_message error_messages[:account_not_confirmed], msg.chat.id
+          end
+        rescue UserNotLoggedInError => e
+          send_message e.message, msg.chat.id
+        end
+
+        def login_event
+          raise UserLoggedInError if user
+
+          user_info = msg.text.split("/").last
+          email, password = user_info.split(":")
+          authenticate_user(email, password)
+        rescue UserNotFoundError, WrongPasswordError, UserLoggedInError => e
+          send_message e.message, msg.chat.id
+        end
+
+        def register_event
+          user_info = msg.text.split("/").last
+          email, password = register_allowed?(user_info)
+          name = msg.from.first_name || "Anonymous"
+
+          RegisterJob.perform_async(email, password, name, 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
+          common_allowed?
+          NewChatJob.perform_async(msg.text.split("/").last, user.id, msg.chat.id)
+        rescue UserNotLoggedInError, AccountNotVerifiedError => e
+          send_message e.message, msg.chat.id
+        end
+
+        def select_chat_event
+          common_allowed?
+          title = msg.text.split("/").last
+          chat = user.chat_by_title(title)
+          select_allowed?(chat)
+
+          send_message success_messages[:chat_selected], msg.chat.id
+        rescue UserNotLoggedInError, ChatNotFoundError, AccountNotVerifiedError => e
+          send_message e.message, msg.chat.id
+        end
+
+        def audio_event
+          audio_allowed?
+          user_audio = transcribe_file(telegram_audio_url)
+          message = Message.new(content: user_audio[:text], chat_id: user.current_chat_id, role: "user")
+          raise MessageNotCreatedError 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, MessageNotCreatedError, AccountNotVerifiedError => e
+          send_message e.message, msg.chat.id
+        end
+
+        def telegram_chat_event
+          common_allowed?
+          chat_if_exists
+        rescue UserNotLoggedInError, AccountNotVerifiedError => e
+          send_message e.message, msg.chat.id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Telegram
+      module EventsController
+        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/")
+          return confirm_account_event if msg.text.include?("confirm/* ")
+        end
+
+        def action_events
+          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?
+
+          raise InvalidCommandError
+        rescue InvalidCommandError => e
+          send_message e.message, msg.chat.id
+        end
+
+        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
+            raise NilError
+          else
+            action_events
+          end
+        rescue NilError => e
+          send_message e.message, msg.chat.id
+        end
+      end
+    end
+  end
+end