chatgpt_assistant 0.1.2 → 0.1.4

data/lib/bots/discord_bot.rb

@@ -1,5 +1,8 @@
 # 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
@@ -21,274 +24,132 @@ module ChatgptAssistant
 
     private
 
-    attr_reader :message
-    attr_accessor :evnt, :user, :chats, :chat
+      include DiscordHelper
+      include DiscordVoiceHelper
 
-    def bot
-      @bot ||= Discordrb::Commands::CommandBot.new(
-        token: discord_token,
-        client_id: discord_client_id,
-        prefix: discord_prefix
-      )
-    end
+      attr_reader :message
+      attr_accessor :evnt, :user, :chats, :chat
 
-    def start_event
-      bot.command :start do |event|
-        @evnt = event
-        @user = event.user
-        start_action
+      def start_event
+        bot.command :start do |event|
+          @evnt = event
+          @user = event.user
+          start_action
+        end
       end
-    end
-
-    def start_action
-      evnt.respond commom_messages[:start_helper].gsub("register/", "gpt!register ")
-      evnt.respond commom_messages[:start_sec_helper].gsub("login/", "gpt!login ")
-    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
+      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
+        end
       end
-    end
 
-    def login_action
-      user_email = message.split(":")[0]
-      user_password = message.split(":")[1]
-      case auth_userdiscord(user_email, user_password, evnt.user.id)
-      when "user not found"
-        evnt.respond error_messages[:user_not_found]
-      when "wrong password"
-        evnt.respond error_messages[:wrong_password]
-      when find_useremail(user_email)
-        evnt.respond success_messages[:user_logged_in]
+      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
+        end
       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
+      def list_event
+        bot.command :list do |event|
+          @evnt = event
+          @user = find_user(discord_id: event.user.id)
+          event.respond error_messages[:user_not_logged_in] if user.nil?
+          event.respond error_messages[:chat_not_found] if user.chats.empty? && user
+          list_action if user && !user.chats.empty?
+        end
       end
-    end
-
-    def register_action
-      user_email = message.split(":")[0]
-      user_password = message.split(":")[1]
-      find_useremail(user_email).nil? ? create_user_action(user_email, user_password) : evnt.respond(error_messages[:user_already_exists])
-    end
-
-    def create_user_action(mail, pass)
-      id = evnt.user.id
-      name = evnt.user.username
-      discord_user_create(id, mail, pass, name) ? evnt.respond(success_messages[:user_created]) : evnt.respond(error_messages[:user_not_created])
-    end
-
-    def list_event
-      bot.command :list do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-        event.respond error_messages[:chat_not_found] if user.chats.empty? && user
-        list_action if user && !user.chats.empty?
-      end
-    end
 
-    def list_action
-      chats_title = user.chats.map(&:title)
-      evnt.respond commom_messages[:chat_list]
-      evnt.respond chats_title.join("\n")
-    end
-
-    def hist_event
-      bot.command :hist do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        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
+      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
+        end
       end
-    end
 
-    def hist_action
-      messages = Message.where(chat_id: chat.id).order(:created_at)
-      messages.each do |message|
-        evnt.respond "#{message.role} - #{message.content}\n#{message.created_at.strftime("%d/%m/%Y %H:%M")}"
+      def help_event
+        bot.command :help do |event|
+          @evnt = event
+          help_action
+        end
       end
-      "This is the end of the chat history"
-    end
 
-    def help_event
-      bot.command :help do |event|
-        @evnt = event
-        help_action
+      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
+        end
       end
-    end
 
-    def help_action
-      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/")
-      evnt.respond message
-    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?
 
-    def new_chat_event
-      bot.command :new_chat do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-        create_chat_action if user
+          sl_chat_action(chat_to_select) if user
+        end
       end
-    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 : evnt.respond(error_messages[:chat_creation])
-    end
-
-    def respond_with_success
-      user.update(current_chat_id: chat.id)
-      evnt.respond success_messages[:chat_created]
-    end
-
-    def sl_chat_event
-      bot.command :sl_chat do |event|
-        @evnt = event
-        chat_to_select = event.message.content.split(" ")[1..].join(" ")
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-
-        sl_chat_action(chat_to_select) if user
+      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
+        end
       end
-    end
-
-    def sl_chat_action(chat_to_select)
-      @chat = user.chat_by_title(chat_to_select)
-      evnt.respond error_messages[:chat_not_found] if chat.nil?
-      user.update(current_chat_id: chat.id) if chat
-      evnt.respond success_messages[:chat_selected] if chat
-    end
 
-    def ask_event
-      bot.command :ask do |event|
-        @evnt = event
-        @message = event.message.content.split(" ")[1..].join(" ")
-        @user = find_userdiscord(event.user.id)
-        event.respond error_messages[:user_not_logged_in] if user.nil?
-        ask_action if user
+      def voice_connect_event
+        bot.command :connect do |event|
+          @evnt = event
+          @user = find_user(discord_id: event.user.id)
+          @chat = Chat.where(id: user.current_chat_id).last
+          voice_connect_checker_action
+          voice_connection_checker_action
+          discord_voice_bot_connect
+        end
       end
-    end
-
-    def ask_action
-      @chat = Chat.where(id: user.current_chat_id).last
-      evnt.respond 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 : evnt.respond(error_messages[:message_not_saved])) if chat
-    end
-
-    def answer_action
-      response = chatter.chat(message.content, chat.id)
-      evnt.respond response
-    end
 
-    def voice_connect_event
-      bot.command :connect do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        @chat = Chat.where(id: user.current_chat_id).last
-        voice_connect_checker_action
-        voice_connection_checker_action
-        bot.voice_connect(event.user.voice_channel) if bot_disconnected?
-        bot_connected? ? "Connected to voice channel" : "Error connecting to voice channel"
+      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
+        end
       end
-    end
-
-    def voice_connect_checker_action
-      evnt.respond error_messages[:user_not_logged_in] if user.nil?
-      evnt.respond error_messages[:chat_not_found] if user && chat.nil?
-    end
 
-    def voice_connection_checker_action
-      evnt.respond error_messages[:user_not_in_voice_channel] if evnt.user.voice_channel.nil? && user
-      evnt.respond error_messages[:bot_already_connected] if evnt.voice && user
-    end
-
-    def bot_disconnected?
-      user && evnt.user.voice_channel && !evnt.voice && !chat.nil?
-    end
-
-    def bot_connected?
-      user && evnt.user.voice_channel && evnt.voice && !chat.nil?
-    end
-
-    def disconnect_event
-      bot.command :disconnect do |event|
-        @evnt = event
-        @user = find_userdiscord(event.user.id)
-        disconnect_checker_action
-        disconnect_action if user && event.user.voice_channel && event.voice
+      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?
+        end
       end
-    end
 
-    def disconnect_checker_action
-      evnt.respond error_messages[:user_not_logged_in] if user.nil?
-      evnt.respond error_messages[:user_not_in_voice_channel] if evnt.user.voice_channel.nil? && user
-      evnt.respond error_messages[:user_not_connected] if !evnt.voice && user
-    end
-
-    def disconnect_action
-      bot.voice_destroy(evnt.user.voice_channel)
-      "Disconnected from voice channel"
-    end
-
-    def speak_event
-      bot.command :speak do |event|
-        @evnt = event
-        @message = event.message.content.split(" ")[1..].join(" ")
-        @user = find_userdiscord(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?
+      def bot_init
+        at_exit { bot.stop }
+        bot.run
+      rescue StandardError => e
+        Error.create(message: e.message, backtrace: e.backtrace)
+        retry
       end
-    end
-
-    def speak_connect_checker_action
-      evnt.respond error_messages[:user_not_logged_in] if user.nil?
-      evnt.respond error_messages[:chat_not_found] if user && evnt.user.voice_channel && evnt.voice && chat.nil?
-    end
-
-    def speak_connection_checker_action
-      evnt.respond error_messages[:user_not_in_voice_channel] if evnt.user.voice_channel.nil? && user
-      evnt.respond 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 = audio_synthesis.synthesize_text(response)
-      speak_answer_action(audio_path, response)
-    end
-
-    def speak_answer_action(audio_path, response)
-      evnt.respond response
-      evnt.voice.play_file(audio_path)
-      delete_all_voice_files
-      "OK"
-    end
-
-    def bot_init
-      at_exit { bot.stop }
-      bot.run
-    rescue StandardError
-      start
-    end
   end
 end

data/lib/bots/helpers/audio_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for audio
+  module AudioHelper
+    def recognition
+      @recognition ||= AudioRecognition.new(openai_api_key)
+    end
+
+    def synthesis
+      @synthesis ||= AudioSynthesis.new(config)
+    end
+
+    def transcribe_file(url)
+      recognition.transcribe_audio(url)
+    end
+  end
+end

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