chatgpt_assistant 0.1.6 → 0.1.7

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,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

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(