chatgpt_assistant 0.1.5 → 0.1.7

data/lib/bots/discord_bot.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "helpers/discord_helper"
-require_relative "helpers/discord_voice_helper"
-
-module ChatgptAssistant
-  # This class is responsible to handle the discord bot
-  class DiscordBot < ApplicationBot
-    def start
-      start_event
-      login_event
-      register_event
-      list_event
-      hist_event
-      help_event
-      new_chat_event
-      sl_chat_event
-      ask_event
-      voice_connect_event
-      disconnect_event
-      speak_event
-      private_message_event
-      bot_init
-    end
-
-    private
-
-      include DiscordHelper
-      include DiscordVoiceHelper
-
-      attr_reader :message
-      attr_accessor :evnt, :user, :chats, :chat
-
-      def start_event
-        bot.command :start do |event|
-          @evnt = event
-          @user = event.user
-          start_action
-          "Ok"
-        end
-      end
-
-      def login_event
-        bot.command :login do |event|
-          @message = event.message.content.split[1]
-          @evnt = event
-          message.nil? ? event.respond(commom_messages[:login]) : login_action
-          "OK"
-        end
-      end
-
-      def register_event
-        bot.command :register do |event|
-          @message = event.message.content.split[1]
-          @evnt = event
-          message.nil? ? event.respond(commom_messages[:register]) : register_action
-          "OK"
-        end
-      end
-
-      def list_event
-        bot.command :list do |event|
-          @evnt = event
-          @user = find_user(discord_id: event.user.id)
-          valid_for_list_action? ? list_action : ""
-          "OK"
-        end
-      end
-
-      def hist_event
-        bot.command :hist do |event|
-          @evnt = event
-          event.respond error_messages[:user_not_logged_in] if user.nil?
-          title = event.message.content.split[1..].join(" ")
-          @chat = user.chat_by_title(title)
-          event.respond error_messages[:chat_not_found] if chat.nil? && user
-          hist_action if user && chat
-          "OK"
-        end
-      end
-
-      def help_event
-        bot.command :help do |event|
-          @evnt = event
-          help_action
-          "OK"
-        end
-      end
-
-      def new_chat_event
-        bot.command :new_chat do |event|
-          @evnt = event
-          @user = find_user(discord_id: event.user.id)
-          event.respond error_messages[:user_not_logged_in] if user.nil?
-          create_chat_action if user
-          "OK"
-        end
-      end
-
-      def sl_chat_event
-        bot.command :sl_chat do |event|
-          @evnt = event
-          chat_to_select = event.message.content.split[1..].join(" ")
-          @user = find_user(discord_id: event.user.id)
-          event.respond error_messages[:user_not_logged_in] if user.nil?
-
-          sl_chat_action(chat_to_select) if user
-          "OK"
-        end
-      end
-
-      def ask_event
-        bot.command :ask do |event|
-          @evnt = event
-          @message = event.message.content.split[1..].join(" ")
-          @user = find_user(discord_id: event.user.id)
-          event.respond error_messages[:user_not_logged_in] if user.nil?
-          ask_action if user
-          "OK"
-        end
-      end
-
-      def voice_connect_event
-        bot.command :connect do |event|
-          @evnt = event
-          @user = find_user(discord_id: event.user.id)
-          if user&.current_chat_id.nil?
-            event.respond error_messages[:no_chat_selected]
-          elsif user&.current_chat_id
-            @chat = Chat.where(id: user.current_chat_id).last
-            voice_connect_checker_action
-            voice_connection_checker_action
-            discord_voice_bot_connect
-          else
-            event.respond error_messages[:user_not_logged_in]
-          end
-          "OK"
-        end
-      end
-
-      def disconnect_event
-        bot.command :disconnect do |event|
-          @evnt = event
-          @user = find_user(discord_id: event.user.id)
-          disconnect_checker_action
-          disconnect_action if user && event.user.voice_channel && event.voice
-          "OK"
-        end
-      end
-
-      def speak_event
-        bot.command :speak do |event|
-          @evnt = event
-          @message = event.message.content.split[1..].join(" ")
-          @user = find_user(discord_id: event.user.id)
-          @chat = user.current_chat
-          speak_connect_checker_action
-          speak_connection_checker_action
-          ask_to_speak_action if user && event.user.voice_channel && event.voice && !chat.nil?
-          "OK"
-        end
-      end
-
-      def private_message_event
-        bot.message do |event|
-          @evnt = event
-          next if discord_next_action?
-
-          @message = event.message.content
-          @user = find_user(discord_id: event.user.id)
-          @chat = user.current_chat if user
-          private_message_action if user && !chat.nil?
-          "OK"
-        end
-      end
-
-      def bot_init
-        at_exit { bot.stop }
-        bot.run
-      rescue StandardError => e
-        Error.create(message: e.message, backtrace: e.backtrace)
-        retry
-      end
-  end
-end

data/lib/bots/helpers/authentication_helper.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Helper for authentication
-  module AuthenticationHelper
-    def valid_password?(password, hash, salt)
-      BCrypt::Engine.hash_secret(password, salt) == hash
-    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
-
-      hash = new_access.password_hash
-      salt = new_access.password_salt
-      valid_password?(password, hash, salt) ? telegram_user_access(_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) }
-      new_access.update(telegram_id: visitor.telegram_id)
-      new_access.email
-    end
-
-    def discord_user_auth(email, password, discord_id)
-      user = find_user(email: email)
-      return "user not found" unless user
-      return "wrong passwords" if password.nil?
-
-      valid_password?(password, user.password_hash, user.password_salt) ? discord_user_access(discord_id, user.email) : "wrong password"
-    end
-
-    def discord_user_access(discord_id, user_email)
-      other_access = where_user(discord_id: discord_id)
-      other_access&.each { |access| access.update(discord_id: nil) }
-      user = find_user(email: user_email)
-      user.update(discord_id: discord_id)
-      user.email
-    end
-  end
-end

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 commom_messages[:start_helper].gsub("register/", "gpt!register ")
-      send_message commom_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 commom_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(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(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/logger_action_helper.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module ChatgptAssistant
-  # Helper for logger action
-  module LoggerActionHelper
-  end
-end

data/lib/bots/helpers/messenger_helper.rb

@@ -1,134 +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])
-      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])
-      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.api.present?
-      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.api.present?
-      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.api.present?
-      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.api.present?
-    end
-
-    def discord_created(chat)
-      evnt.respond "Intructions sended to actor:\n#{chat.prompt}" unless chat.actor.nil?
-      evnt.respond "Response from assistant:\n#{chat.messages[1].content}" 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])
-      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])
-      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])
-      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])
-      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])
-      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])
-      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])
-      evnt&.respond(success_messages[:user_logged_in])
-    end
-  end
-end

data/lib/bots/helpers/telegram_helper.rb

@@ -1,77 +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 commom_messages[:start], msg.chat.id
-      help_message = help_messages.join("\n").to_s
-      send_message help_message, msg.chat.id
-      send_message commom_messages[:start_helper], msg.chat.id
-      send_message commom_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_user_history
-      user.current_chat.messages.last(10).map { |m| "#{m.role}: #{m.content}\nat: #{m.created_at}" }
-    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