chatgpt_assistant 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c2a41c81a5e742715d9b0710ff7c5866ba40d718931c3a6f0caa470613b23cd
-  data.tar.gz: 73d6d84ccabd93c017b776083689f799f78e7b81355f02ca33a552fba601cf89
+  metadata.gz: c735d019dd75e4679918ae36b75d61978f78cf4b7ca11c8530915cc738cb7ec6
+  data.tar.gz: 73bdda5095040e37e3bb270c287ec8549fe156749a35b28ecca592c5205b17c9
 SHA512:
-  metadata.gz: e55c21e292cc6bb2ee86bf86dca5ed881a02e834e30b5bf982f028dd0e34cf23c6c1978274873a04c50a845f157034cc1132050104d13899dce97d3c62e808cd
-  data.tar.gz: ca83c1370beed7b168375ed3f8ecfd168950d0fde50c72a12784e2c28a58660c5838de0c969528bd8a47ddca11b1bc6a121c825f370a20165a09dda5fec0d59e
+  metadata.gz: 5ebf7e87f62c820eb5988dfe6a0635d385a2329bdb7b690e5ee15bac182ab162f8e502b111d14fb4c66aa6923a702e57b7f8ae5fef351582ff5b1a9a1bd7bf8f
+  data.tar.gz: 78367d4df7a05b0290889fb854a925abd239b277e8fe9f7236db9c6715405c989f40ed0d732c0db05e3abd6e63c70099c96317fe5f3c13213f53aa26d5cf84f8

data/.env_prod_sample

@@ -3,7 +3,7 @@ LANGUAGE=en # or pt currently
 MODE=aws # or ibm
 DISCORD_PREFIX=gpt!
 
-POSTGRES_DB=telegram_chatgpt_development # or your database
+POSTGRES_DB=chatgpt_assistant_production # or your database
 POSTGRES_USER=postgres # or your user
 POSTGRES_PASSWORD=postgres # or your password
 

data/.env_sample

@@ -3,7 +3,7 @@ LANGUAGE=en # or pt currently
 MODE=aws # or ibm
 DISCORD_PREFIX=dgpt!
 
-POSTGRES_DB=telegram_chatgpt_development # or your database
+POSTGRES_DB=chatgpt_assistant_development # or your database
 POSTGRES_USER=postgres # or your user
 POSTGRES_PASSWORD=postgres # or your password
 

data/.rubocop.yml

@@ -12,15 +12,26 @@ Style/StringLiteralsInInterpolation:
 Layout/LineLength:
   Max: 160
 
-# remove code length limit
+Metrics/ModuleLength:
+  Max: 120
+
 Metrics/MethodLength:
   Max: 200
 
-# Metrics/BlockLength:
-#   Enabled: false
+Metrics/BlockLength:
+  Max: 200
 
 Metrics/ClassLength:
-  Enabled: false
+  Max: 300
 
 Metrics/AbcSize:
-  Max: 40
+  Max: 35
+
+Layout/AccessModifierIndentation:
+  EnforcedStyle: indent
+  
+Layout/IndentationWidth:
+  Width: 2
+
+Layout/IndentationConsistency:
+  EnforcedStyle: indented_internal_methods

data/Dockerfile

@@ -5,11 +5,8 @@ COPY Gemfile /chatgpt_assistant/Gemfile
 COPY Gemfile.lock /chatgpt_assistant/Gemfile.lock
 RUN bundle install
 
-# Opus Installation for voice messages
-
 RUN apt-get install -y wget
 RUN wget https://archive.mozilla.org/pub/opus/opus-1.3.1.tar.gz
 RUN tar -xvf opus-1.3.1.tar.gz
 RUN cd opus-1.3.1 && ./configure && make && make install
-RUN rm -rf opus-1.3.1.tar.gz opus-1.3.1
-
+RUN rm -rf opus-1.3.1.tar.gz opus-1.3.1

data/exe/chatgpt_assistant

@@ -31,7 +31,7 @@ end
 end
 
 %w[deploy_and_build.sh deploy.sh].each do |file|
-  `cp #{gem_dir}/bin/#{file} #{path}`
+  `cp #{gem_dir}/#{file} #{path}`
 end
 
 %w[/.bundle/ /.yardoc /_yardoc/ /coverage/ /doc/ /pkg/ /spec/reports/ /tmp/ /db_data /db_data/*
@@ -42,7 +42,7 @@ end
 `cd #{path} && git init`
 
 `mkdir -p #{path}/.github/workflows`
-`cp #{gem_dir}/.github/workflows/*.yml #{path}/.github/workflows`
+`cp #{gem_dir}/workflows/*.yml #{path}/.github/workflows`
 
 puts "Done! Now you can run 'cd #{path} && bundle install'"
 puts "Build the docker image with 'rake compose:build'"

data/lib/bots/application_bot.rb

@@ -1,8 +1,25 @@
 # frozen_string_literal: true
 
+require_relative "helpers/messenger_helper"
+require_relative "helpers/authentication_helper"
+require_relative "helpers/visit_helper"
+require_relative "helpers/audio_helper"
+require_relative "helpers/logger_action_helper"
+require_relative "helpers/search_helper"
+require_relative "helpers/validation_helper"
+require_relative "helpers/file_helper"
 module ChatgptAssistant
   # This class is responsible to contain the shared variables between the bot classes
   class ApplicationBot
+    include MessengerHelper
+    include AuthenticationHelper
+    include VisitHelper
+    include AudioHelper
+    include LoggerActionHelper
+    include SearchHelper
+    include ValidationHelper
+    include FileHelper
+
     def initialize(config)
       @config = config
       default_msg = DefaultMessages.new(@config.language)
@@ -19,100 +36,14 @@ module ChatgptAssistant
       @help_messages = default_msg.help_messages
     end
 
-    def chatter
-      @chatter ||= Chatter.new(openai_api_key)
-    end
-
-    def audio_recognition
-      @audio_recognition ||= AudioRecognition.new(openai_api_key)
-    end
-
-    def audio_synthesis
-      @audio_synthesis ||= AudioSynthesis.new(config)
-    end
-
-    def transcribed_text
-      audio_recognition.transcribe_audio(audio_url)
-    end
-
-    def find_useremail(email)
-      User.find_by(email: email)
-    end
-
-    def find_userdiscord(discord_id)
-      User.find_by(discord_id: discord_id)
-    end
-
-    def find_usertelegram(telegram_id)
-      User.find_by(telegram_id: telegram_id)
-    end
-
-    def valid_password?(user, password)
-      return false if password.nil?
-
-      salt = user.password_salt
-      password_hash = user.password_hash
-
-      BCrypt::Engine.hash_secret(password, salt) == password_hash
-    end
-
-    def auth_userdiscord(email, password, discord_id)
-      user = find_useremail(email)
-      return "user not found" unless user
-      return "wrong password" if password.nil?
-
-      valid_password?(user, password) ? user_disc_access(discord_id, user.email) : "wrong password"
-    end
-
-    def user_disc_access(discord_id, user_email)
-      last_access = find_userdiscord(discord_id)
-      new_access = find_useremail(user_email)
-      last_acess.update(discord_id: nil) if last_access && (last_access != new_access)
-      new_access.update(discord_id: discord_id)
-      new_access
-    end
-
-    def discord_user_create(discord_id, email, password, name)
-      user = User.new(discord_id: discord_id, email: email, password_hash: password, name: name)
-      last_access = find_userdiscord(discord_id)
-      last_access&.update(discord_id: nil)
-      user.save
-    end
-
-    def auth_usertelegram(email, password, telegram_id)
-      user = find_useremail(email)
-      return "user not found" unless user
-      return "wrong password" if password.nil?
-
-      valid_password?(user, password) ? user_tele_access(telegram_id, user.email) : "wrong password"
-    end
-
-    def user_tele_access(telegram_id, user_email)
-      last_access = find_usertelegram(telegram_id)
-      new_access = find_useremail(user_email)
-      last_acess.update(telegram_id: nil) if last_access && (last_access != new_access)
-      new_access.update(telegram_id: telegram_id)
-      new_access
-    end
-
-    def telegram_user_create(telegram_id, email, password, name)
-      user = User.new(telegram_id: telegram_id, email: email, password_hash: password, name: name)
-      last_access = find_usertelegram(telegram_id)
-      last_access&.update(telegram_id: nil)
-      user.save
-    end
-
-    def delete_all_voice_files
-      Dir.glob("voice/*").each do |file|
-        next if [".keep", "voice/.keep"].include?(file)
-
-        File.delete(file)
-      end
-    end
-
     attr_reader :openai_api_key, :telegram_token, :database, :default_msg,
                 :mode, :config, :discord_token, :discord_client_id,
                 :discord_prefix, :commom_messages, :error_messages, :success_messages,
                 :help_messages
+    attr_accessor :msg, :evnt, :bot, :audio_url, :visitor, :user, :chat, :chat_id
+
+    def chatter
+      @chatter ||= Chatter.new(openai_api_key)
+    end
   end
 end

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