chatgpt_assistant 0.1.6 → 0.1.7

data/lib/bots/helpers/messenger_helper.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Helper for messenger
-  module MessengerHelper
-    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 respond_with_success(chat)
-      user.update(current_chat_id: chat.id)
-      send_message success_messages[:chat_created]
-    end
-
-    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
-
-    def send_message(text, chat_id = nil)
-      @send_message = bot.respond_to?(:api) ? telegram_send_message(text, chat_id) : discord_send_message(text)
-    end
-
-    def telegram_send_message(text, chat_id)
-      messages = parse_message(text, 4096)
-      messages.each { |m| bot.api.send_message(chat_id: chat_id, text: m) }
-    end
-
-    def discord_send_message(text)
-      messages = parse_message(text, 2000)
-      messages.each { |m| evnt.respond m }
-    end
-
-    def discord_help_message
-      help_messages.join("\n").gsub(" /", discord_prefix)
-                   .gsub("register/", "#{discord_prefix}register ")
-                   .gsub("login/", "#{discord_prefix}login ")
-                   .gsub("new_chat/", "#{discord_prefix}new_chat/")
-                   .gsub("sl_chat/", "#{discord_prefix}sl_chat/")
-    end
-
-    def user_logged_message
-      user.update(telegram_id: msg.chat.id)
-      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in]) if bot.respond_to?(:api)
-      evnt&.respond success_messages[:user_logged_in] if evnt.present?
-    end
-
-    def invalid_command_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:invalid_command]) if bot.respond_to?(:api)
-      evnt&.respond error_messages[:invalid_command]
-    end
-
-    def user_not_found_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_found]) if bot.respond_to?(:api)
-      evnt&.respond error_messages[:user_not_found] if evnt.present?
-    end
-
-    def user_created_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_created]) if bot.respond_to?(:api)
-      evnt&.respond success_messages[:user_created] if evnt.present?
-    end
-
-    def user_creation_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_creation]) if bot.respond_to?(:api)
-      evnt&.respond error_messages[:user_creation] if evnt.present?
-    end
-
-    def chat_created_message(chat)
-      user&.update(current_chat_id: chat.id)
-      return telegram_created(chat) if bot.respond_to?(:api)
-
-      discord_created(chat)
-    end
-
-    def telegram_created(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
-
-    def discord_created(chat)
-      evnt.respond "Intructions sended to actor:\n#{chat.prompt}" unless chat.actor.nil?
-      evnt.respond success_messages[:chat_created] if evnt.present?
-    end
-
-    def not_logged_in_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:user_not_logged_in]) if bot.respond_to?(:api)
-      evnt&.respond(error_messages[:user_not_logged_in])
-    end
-
-    def wrong_password_error_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:password]) if bot.respond_to?(:api)
-      evnt&.respond(error_messages[:password])
-    end
-
-    def chat_not_found_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:chat_not_found]) if bot.respond_to?(:api)
-      evnt&.respond(error_messages[:chat_not_found])
-    end
-
-    def no_chat_selected_message
-      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:no_chat_selected]) if bot.respond_to?(:api)
-      evnt&.respond(error_messages[:no_chat_selected])
-    end
-
-    def no_messages_founded_message
-      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:no_messages_founded]) if bot.respond_to?(:api)
-      evnt&.respond(error_messages[:no_messages_founded])
-    end
-
-    def chat_creation_failed_message
-      bot&.api&.send_message(chat_id: msg.chat.id, text: error_messages[:chat_creation_failed]) if bot.respond_to?(:api)
-      evnt&.respond(error_messages[:chat_creation_failed])
-    end
-
-    def user_logged_in_message
-      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:user_logged_in]) if bot.respond_to?(:api)
-      evnt&.respond(success_messages[:user_logged_in])
-    end
-  end
-end

data/lib/bots/helpers/telegram_helper.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Helper for telegram
-  module TelegramHelper
-    def user
-      @user = find_user(telegram_id: msg.chat.id)
-    end
-
-    def bot
-      @bot ||= Telegram::Bot::Client.new(telegram_token)
-    end
-
-    def telegram_chat_event
-      user ? chat_if_exists : not_logged_in_message
-    end
-
-    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) : chat_creation_failed_message
-    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_actions?
-      msg.text.include?("new_chat/") || msg.text.include?("sl_chat/") || msg.text.include?("login/") || msg.text.include?("register/")
-    end
-  end
-end

data/lib/bots/helpers/telegram_voice_helper.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Telegram Voice Helper
-  module TelegramVoiceHelper
-    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

data/lib/bots/helpers/validation_helper.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # This module is responsible for the validation of the bot actions
-  module ValidationHelper
-    def valid_for_list_action?
-      not_logged_in_message if user.nil?
-      chat_not_found_message if user.chats.count.zero?
-      !user.nil? && user.chats.count.positive?
-    end
-
-    def chat_if_exists
-      chat = Chat.find_by(user_id: user.id, id: user.current_chat_id)
-      chat ? chat_success(chat.id) : no_chat_selected_message
-    end
-
-    def visitor_user?
-      visitor&.tel_user.nil? && visitor&.dis_user.nil?
-    end
-
-    def discord_voice_bot_disconnected?
-      user && evnt.user.voice_channel && !evnt.voice && !chat.nil?
-    end
-
-    def discord_voice_bot_connected?
-      user && evnt.user.voice_channel && evnt.voice && !chat.nil?
-    end
-
-    def discord_next_action?
-      return true if evnt.channel.type != 1 && evnt.channel.name != "ai-spaces"
-
-      %w[login register start help new_chat sl_chat ask list hist connect disconnect speak].each do |action|
-        return true if evnt.message.content.include?("#{discord_prefix}#{action}")
-      end
-      false
-    end
-  end
-end

data/lib/bots/helpers/visit_helper.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Helper for visit
-  module VisitHelper
-    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 discord_visited?(user_id)
-      return unless evnt
-
-      visitor = Visitor.find_by(discord_id: user_id, name: evnt.user.name)
-      if visitor.nil?
-        Visitor.create(discord_id: user_id, name: evnt.user.name)
-      else
-        visitor
-      end
-    end
-  end
-end

data/lib/bots/services/new_chat_service.rb

@@ -1,34 +0,0 @@
-#  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 call
-      raise ChatAlreadyExistsError if Chat.find_by(title: @chat_title)
-      raise NilError if @chat_title.nil?
-      raise NilError if @user_id.nil?
-      raise NilError if @chat_id.nil?
-
-      chat = Chat.new(title: @chat_title, user_id: @user_id)
-      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/bots/services/register_service.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # This class is responsible to background the register service
-  class RegisterService
-    def initialize(email, password, chat_id)
-      @email = email
-      @password = password
-      @chat_id = chat_id
-      @config = Config.new
-      @config.db_connection
-    end
-
-    def telegram_async
-      TelegramBot.new(@config)
-    end
-
-    def call
-      user = User.find_by(email: @email)
-      if user
-        telegram_async.send_message("User already exists", @chat_id)
-      else
-        user = User.new(email: @email, password: @password, telegram_id: @chat_id)
-        if user.save
-          telegram_async.send_message("User created", @chat_id)
-        else
-          raise UserAlreadyExistsError if User.find_by(email: @email)
-          raise WrongEmailError if user.errors[:email].any?
-          raise WrongPasswordError if user.errors[:password].any?
-        end
-      end
-    rescue UserAlreadyExistsError, WrongEmailError, WrongPasswordError => e
-      telegram_async.send_message(e.message, @chat_id)
-    end
-  end
-end

data/lib/bots/telegram_bot.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "helpers/telegram_helper"
-require_relative "helpers/telegram_voice_helper"
-
-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
-
-      include TelegramHelper
-      include TelegramVoiceHelper
-
-      attr_accessor :msg, :visitor, :chat, :chat_id
-
-      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
-
-      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
-        raise UserNotLoggedInError if user.nil?
-        raise NoChatSelectedError if user.current_chat.nil?
-        raise NoMessagesFoundedError if user.current_chat.messages.count.zero?
-
-        user.chat_history.each do |m|
-          send_message m, msg.chat.id
-        end
-      rescue NoChatSelectedError, UserNotLoggedInError, NoMessagesFoundedError => e
-        send_message e.message, msg.chat.id
-      end
-
-      def list_event
-        raise UserNotLoggedInError if user.nil?
-        raise NoChatsFoundedError if user.chats.count.zero?
-
-        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 => e
-        send_message e.message, msg.chat.id
-      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 auth_event?
-        msg.text.include?("login/") || msg.text.include?("register/") || msg.text.include?("sign_out/")
-      end
-
-      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/")
-      end
-
-      def login_event
-        raise UserLoggedInError if user
-
-        user_info = msg.text.split("/").last
-        email, password = user_info.split(":")
-        case telegram_user_auth(email, password, msg.chat.id)
-        when "user not found"
-          raise UserNotFoundError
-        when "wrong password"
-          raise WrongPasswordError
-        when email
-          user_logged_in_message
-        end
-      rescue UserNotFoundError, WrongPasswordError, UserLoggedInError => e
-        send_message e.message, msg.chat.id
-      end
-
-      def register_event
-        user_info = msg.text.split("/").last
-        raise NoRegisterInfoError if user_info.nil?
-        raise UserLoggedInError if user
-
-        email, password = user_info.split(":")
-        raise NoRegisterInfoError if email.nil? || password.nil?
-
-        RegisterJob.perform_async(email, password, 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
-        raise UserNotLoggedInError if user.nil?
-
-        NewChatJob.perform_async(msg.text.split("/").last, user.id, msg.chat.id)
-      rescue UserNotLoggedInError => e
-        send_message e.message, msg.chat.id
-      end
-
-      def select_chat_event
-        raise UserNotLoggedInError if user.nil?
-
-        title = msg.text.split("/").last
-        chat = user.chat_by_title(title)
-        raise ChatNotFoundError if chat.nil?
-
-        raise ChatNotFoundError unless user.update(current_chat_id: chat.id)
-
-        send_message success_messages[:chat_selected], msg.chat.id
-      rescue UserNotLoggedInError, ChatNotFoundError => e
-        send_message e.message, msg.chat.id
-      end
-
-      def audio_event
-        raise UserNotLoggedInError if user.nil?
-        raise NoChatSelectedError if user.current_chat.nil?
-
-        user_audio = transcribe_file(telegram_audio_url)
-        message = Message.new(content: user_audio[:text], chat_id: user.current_chat_id, role: "user")
-        raise MessageNotSavedError 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, MessageNotSavedError => e
-        send_message e.message, msg.chat.id
-      end
-  end
-end