chatgpt_assistant 0.1.6 → 0.1.8

data/lib/bots/helpers/discord_helper.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Helper for discord
-  module DiscordHelper
-    def bot
-      @bot ||= Discordrb::Commands::CommandBot.new(
-        token: discord_token,
-        client_id: discord_client_id,
-        prefix: discord_prefix
-      )
-    end
-
-    def start_action
-      send_message common_messages[:start_helper].gsub("register/", "gpt!register ")
-      send_message common_messages[:start_sec_helper].gsub("login/", "gpt!login ")
-    end
-
-    def login_action
-      user_email, user_password = message.split(":")
-      case discord_user_auth(user_email, user_password, evnt.user.id)
-      when "user not found"
-        send_message error_messages[:user_not_found]
-      when "wrong password"
-        puts "wrong password"
-        send_message error_messages[:wrong_password]
-      when find_user(email: user_email).email
-        send_message success_messages[:user_logged_in]
-      end
-    end
-
-    def create_user_action(mail, pass)
-      id = evnt.user.id
-      return send_message(success_messages[:user_created]) if discord_user_create(id, mail, pass)
-
-      send_message(error_messages[:user_not_created])
-    end
-
-    def register_action
-      user_email = message.split(":")[0]
-      user_password = message.split(":")[1]
-      return create_user_action(user_email, user_password) if find_user(email: user_email).nil?
-
-      send_message(error_messages[:user_already_exists])
-    end
-
-    def list_action
-      chats_title = user.chats.map(&:title)
-      send_message common_messages[:chat_list]
-      send_message chats_title.join("\n")
-    end
-
-    def hist_action
-      messages = Message.where(chat_id: chat.id).order(:created_at)
-      messages.each { |m| send_message "#{m.role} - #{m.content}\n#{m.created_at.strftime("%d/%m/%Y %H:%M")}" }
-      "This is the end of the chat history"
-    end
-
-    def help_action
-      message = discord_help_message
-      send_message message
-    end
-
-    def ask_action
-      @chat = Chat.where(id: user.current_chat_id).last
-      send_message error_messages[:chat_not_found] if chat.nil?
-      @message = Message.new(chat_id: chat.id, content: message, role: "user") if chat
-      (message.save ? answer_action : send_message(error_messages[:message_not_saved])) if chat
-    end
-
-    def private_message_action
-      @chat = Chat.where(id: user.current_chat_id).last
-      send_message error_messages[:chat_not_found] if chat.nil?
-      @message = Message.new(chat_id: chat.id, content: message, role: "user") if chat
-      (message.save ? answer_action : send_message(error_messages[:message_not_saved])) if chat
-    end
-
-    def sl_chat_action(chat_to_select)
-      @chat = user.chat_by_title(chat_to_select)
-      send_message error_messages[:chat_not_found] if chat.nil?
-      user.update(current_chat_id: chat.id) if chat
-      send_message success_messages[:chat_selected] if chat
-    end
-
-    def create_chat_action
-      title = evnt.message.content.split[1..].join(" ")
-      mode = nil
-      if title.include? ":"
-        mode = title.split(":").last.to_i
-        title = title.split(":").first
-      end
-      actors = AwesomeChatgptActors::CastControl.actors
-      return send_message "invalid mode" unless (mode.to_i >= 1 && mode.to_i <= actors.size + 1) || mode.nil?
-      return send_message "invalid chat title" if title.nil? || title.empty?
-      return send_message "chat title already exists" if user.chat_by_title(title)
-
-      actor_name = actors[mode.to_i - 1] if mode
-      actor = AwesomeChatgptActors::Actor.new(role: actor_name, language: config.language) 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(error_messages[:chat_creation])
-    end
-
-    def answer_action
-      response = chatter.chat(message.content, chat.id, error_messages[:something_went_wrong])
-      send_message response
-    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
-
-    def discord_user_create(discord_id, email, password)
-      user = User.new(discord_id: discord_id, email: email, password: password)
-      last_access = find_user(discord_id: discord_id)
-      last_access&.update(discord_id: nil)
-      user.save
-    end
-  end
-end

data/lib/bots/helpers/discord_voice_helper.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Helper for voice actions
-  module DiscordVoiceHelper
-    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 ask_to_speak_action
-      Message.create(chat_id: chat.id, content: message, role: "user")
-      response = chatter.chat(message, chat.id, error_messages[:something_went_wrong])
-      audio_path = synthesis.synthesize_text(response)
-      speak_answer_action(audio_path, response)
-    end
-
-    def speak_answer_action(audio_path, response)
-      send_message response
-      evnt.voice.play_file(audio_path)
-      delete_file audio_path
-      "OK"
-    end
-
-    def discord_voice_bot_connect
-      bot.voice_connect(evnt.user.voice_channel) if discord_voice_bot_disconnected?
-      discord_voice_bot_connected? ? "Connected to voice channel" : "Error connecting to voice channel"
-    end
-
-    def disconnect_action
-      bot.voice_destroy(evnt.user.voice_channel)
-      "Disconnected from voice channel"
-    end
-  end
-end

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