chatgpt_assistant 0.1.6 → 0.1.8

data/lib/chatgpt_assistant/bots/discord_bot.rb

@@ -0,0 +1,41 @@
+# 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"
+require_relative "discord/validations"
+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
+      private_message_event
+      bot_init
+    end
+
+    private
+
+      attr_reader :message
+      attr_accessor :evnt, :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
+      include Bots::Discord::Validations
+  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}/jobs/register_job.rb

@@ -9,8 +9,8 @@ module ChatgptAssistant
 
     sidekiq_options queue: :default
 
-    def perform(email, password, chat_id)
-      RegisterService.new(email, password, chat_id).call
+    def perform(email, password, name, chat_id)
+      RegisterService.new(email, password, name, chat_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/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,121 @@
+# 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?(name, token)
+            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]
+          delete_file user_audio[:file]
+        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

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?(name, token)
+          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