chatgpt_assistant 0.1.1 → 0.1.3

data/lib/bots/helpers/authentication_helper.rb

@@ -0,0 +1,47 @@
+# 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(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) }
+      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)
+      last_access = find_user(discord_id: discord_id)
+      new_access = find_user(email: user_email)
+      last_acess.update(discord_id: nil) if last_access&.email != new_access&.email
+      new_access&.update(discord_id: discord_id)
+      new_access.email
+    end
+  end
+end

data/lib/bots/helpers/discord_helper.rb

@@ -0,0 +1,102 @@
+# 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 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
+      chat_title = evnt.message.content.split(" ")[1..].join(" ")
+      @chat = Chat.new(user_id: user.id, title: chat_title, status: 0)
+      chat.save ? respond_with_success : send_message(error_messages[:chat_creation])
+    end
+
+    def answer_action
+      response = chatter.chat(message.content, chat.id)
+      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

@@ -0,0 +1,50 @@
+# 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)
+      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/file_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for files
+  module FileHelper
+    def delete_file(file)
+      File.delete file
+    end
+  end
+end

data/lib/bots/helpers/logger_action_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for logger action
+  module LoggerActionHelper
+    def register_visitor_action(action, visitor_id)
+      VisitorAction.create(visitor_id: visitor_id, action: action, description: msg.text)
+    end
+
+    def register_user_action(action, user_id)
+      UserAction.create(user_id: user_id, action: action, description: msg.text)
+    end
+  end
+end

data/lib/bots/helpers/messenger_helper.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for messenger
+  module MessengerHelper
+    def chat_success(chat_id)
+      Message.create(chat_id: chat_id, content: msg.text, role: "user")
+      text = chatter.chat(msg.text, chat_id)
+      mess = parse_message(text, 4096)
+      mess.each { |m| send_message m, msg.chat.id }
+    end
+
+    def respond_with_success
+      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)
+      bot.api.send_message(chat_id: chat_id, text: text)
+    end
+
+    def discord_send_message(text)
+      evnt.respond text
+    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
+      register_user_action("login", user.id)
+      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
+      register_user_action("invalid_command", user.id) if user
+      register_visitor_action("invalid_command", visitor.id) if visitor&.tel_user.nil?
+      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
+      register_visitor_action("error: user not found", visitor.id)
+      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
+      register_visitor_action("user_created", visitor.id)
+      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
+      register_visitor_action("error: user creation", visitor.id)
+      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)
+      register_user_action("chat_created", user.id) if user
+      user&.update(current_chat_id: chat.id)
+      bot.api&.send_message(chat_id: msg.chat.id, text: success_messages[:chat_created]) if bot.api.present?
+    end
+
+    def not_logged_in_message
+      register_visitor_action("error: not logged in", visitor.id) if visitor_user?
+      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
+      register_visitor_action("error: wrong password", visitor.id) if visitor_user?
+      bot.api&.send_message(chat_id: msg.chat.id, text: error_messages[:password])
+      evnt&.respond(error_messages[:password])
+    end
+
+    def chat_not_found_message
+      register_visitor_action("error: visitors cant select chat", visitor.id) if visitor_user?
+      register_user_action("error: chat not found", user.id) if user
+      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
+      register_visitor_action("error: visitors cant select chat", visitor.id) if visitor_user?
+      register_user_action("error: no chat selected", user.id) if user
+      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
+      register_visitor_action("error: visitors cant view the chat history", visitor.id) if visitor_user?
+      register_user_action("error: no messages founded", user.id) if user
+      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
+      register_visitor_action("error: chat creation failed", visitor.id) if visitor_user?
+      register_user_action("error: chat creation failed", user.id) if user
+      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
+      register_visitor_action("user_logged_in", visitor.id) if visitor
+      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/search_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for search
+  module SearchHelper
+    def find_visitor(telegram_id: nil, discord_id: nil)
+      if telegram_id
+        Visitor.find_by(telegram_id: telegram_id)
+      elsif discord_id
+        Visitor.find_by(discord_id: discord_id)
+      end
+    end
+
+    def find_user(telegram_id: nil, discord_id: nil, email: nil)
+      if telegram_id
+        User.find_by(telegram_id: telegram_id)
+      elsif discord_id
+        User.find_by(discord_id: discord_id)
+      elsif email
+        User.find_by(email: email)
+      end
+    end
+
+    def where_user(telegram_id: nil, discord_id: nil, email: nil)
+      if telegram_id
+        User.where(telegram_id: telegram_id)
+      elsif discord_id
+        User.where(discord_id: discord_id)
+      elsif email
+        User.where(email: email)
+      end
+    end
+  end
+end

data/lib/bots/helpers/telegram_helper.rb

@@ -0,0 +1,89 @@
+# 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_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)
+      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
+
+    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
+      chat = Chat.new(user_id: user.id, status: 0, title: title)
+      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/validation_helper.rb

@@ -0,0 +1,29 @@
+# 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
+  end
+end

data/lib/bots/helpers/visit_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for visit
+  module VisitHelper
+    def telegram_visited?(chat_id)
+      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)
+      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