chatgpt_assistant 0.1.6 → 0.1.7

data/docker-compose.yml

@@ -18,29 +18,33 @@ services:
     build: .
     command: bash -c "exe/chatgpt_bot telegram"
     volumes:
-      - .:/chatgpt_assistant
+      - .:/assistant
     environment:
       POSTGRES_HOST: db
     env_file:
       - .env
     depends_on:
       - db
+      - redis
+      - sidekiq
   discord:
     build: .
     command: bash -c "exe/chatgpt_bot discord"
     volumes:
-      - .:/chatgpt_assistant
+      - .:/assistant
     environment:
       POSTGRES_HOST: db
     env_file:
       - .env
     depends_on:
       - db
+      - redis
+      - sidekiq
   sidekiq:
     build: .
     command: bash -c "exe/chatgpt_bot sidekiq"
     volumes:
-      - .:/chatgpt_assistant
+      - .:/assistant
     environment:
       POSTGRES_HOST: db
     env_file:
@@ -49,4 +53,4 @@ services:
       - db
       - redis
 volumes:
-  postgres:
+  postgres:

data/exe/chatgpt_assistant

@@ -26,7 +26,7 @@ gem_dir = Gem::Specification.find_by_name("chatgpt_assistant").gem_dir
   `cp #{gem_dir}/#{file} #{path}`
 end
 
-%w[docker-compose.yml docker-compose.prod.yml Dockerfile LICENSE LICENSE.txt].each do |file|
+%w[docker-compose.yml Dockerfile LICENSE LICENSE.txt].each do |file|
   `cp #{gem_dir}/#{file} #{path}`
 end
 

data/lib/{bots → chatgpt_assistant/bots}/application_bot.rb

@@ -2,11 +2,8 @@
 
 # helpers
 require_relative "helpers/messenger_helper"
-require_relative "helpers/authentication_helper"
-require_relative "helpers/visit_helper"
 require_relative "helpers/audio_helper"
 require_relative "helpers/search_helper"
-require_relative "helpers/validation_helper"
 require_relative "helpers/file_helper"
 
 # jobs
@@ -23,11 +20,8 @@ module ChatgptAssistant
   # This class is responsible to contain the shared attributes and methods
   class ApplicationBot
     include MessengerHelper
-    include AuthenticationHelper
-    include VisitHelper
     include AudioHelper
     include SearchHelper
-    include ValidationHelper
     include FileHelper
 
     def initialize(config)

data/lib/chatgpt_assistant/bots/discord/actions.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module Actions
+        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 start_action
+          fields = %w[login start help new_chat sl_chat ask list hist connect disconnect speak]
+
+          values_hash = {
+            login: "Account login, use: #{discord_prefix}login email:password",
+            start: "Start the bot, use: #{discord_prefix}start",
+            help: "Show this message, use: #{discord_prefix}help",
+            new_chat: "Create a new chat, use: #{discord_prefix}new_chat chat_name",
+            sl_chat: "Select a chat, use: #{discord_prefix}sl_chat chat_name",
+            ask: "Ask a question, use: #{discord_prefix}ask question",
+            list: "List all chats, use: #{discord_prefix}list",
+            hist: "Show chat history, use: #{discord_prefix}hist",
+            connect: "Connect to voice channel, use: #{discord_prefix}connect",
+            disconnect: "Disconnect from voice channel, use: #{discord_prefix}disconnect",
+            speak: "Speak in voice channel, use: #{discord_prefix}speak question"
+          }
+
+          embed = Discordrb::Webhooks::Embed.new(
+            title: "Hello, #{evnt.user.name}!",
+            description: "I'm ChatGPT Assistant, see my commands below:",
+            color: "00FF00",
+            fields: fields.map { |field| { name: field, value: values_hash[field.to_sym] } }
+          )
+          evnt.respond nil, false, embed
+        end
+
+        def help_action
+          start_action
+        end
+
+        def list_action
+          chats = user.chats
+
+          embed = Discordrb::Webhooks::Embed.new(
+            title: "Hello, #{evnt.user.name}!",
+            description: "Your chats:",
+            color: "00FF00",
+            fields: chats.map { |field| { name: field.title, value: field.actor || "No prompt" } }
+          )
+
+          evnt.respond nil, false, embed
+        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 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 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
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/discord/auth.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module Auth
+        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
+
+        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?
+
+          user.valid_password?(password) ? 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
+  end
+end

data/lib/chatgpt_assistant/bots/discord/bot.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module Bot
+        def bot
+          @bot ||= Discordrb::Commands::CommandBot.new(
+            token: discord_token,
+            client_id: discord_client_id,
+            prefix: discord_prefix
+          )
+        end
+
+        def user
+          @user = find_user(discord_id: evnt.user.id)
+        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
+  end
+end

data/lib/chatgpt_assistant/bots/discord/chat_actions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module ChatActions
+        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 answer_action
+          response = chatter.chat(message.content, chat.id, error_messages[:something_went_wrong])
+          send_message response
+        end
+
+        def send_message(text)
+          messages = parse_message(text, 2000)
+          messages.each { |m| evnt.respond m }
+        end
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/discord/events.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module Events
+        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(common_messages[:login]) : login_action
+            "OK"
+          end
+        end
+
+        def list_event
+          bot.command :list do |event|
+            @evnt = event
+            list_action if valid_for_list_action?
+            "OK"
+          end
+        end
+
+        def hist_event
+          bot.command :hist do |event|
+            @evnt = event
+            @chat = user.current_chat
+            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
+            event.respond error_messages[:user_not_logged_in] if user.nil?
+            event.respond error_messages[:account_not_verified] if user && !user.active?
+            create_chat_action if user&.active?
+            "OK"
+          end
+        end
+
+        def sl_chat_event
+          bot.command :sl_chat do |event|
+            @evnt = event
+            chat_to_select = event.message.content.split[1..].join(" ")
+            event.respond error_messages[:user_not_logged_in] if user.nil?
+            event.respond error_messages[:account_not_verified] if user && !user.active?
+            sl_chat_action(chat_to_select) if user&.active?
+            "OK"
+          end
+        end
+
+        def ask_event
+          bot.command :ask do |event|
+            @evnt = event
+            @message = event.message.content.split[1..].join(" ")
+            event.respond error_messages[:user_not_logged_in] if user.nil?
+            event.respond error_messages[:account_not_verified] if user && !user.active?
+            ask_action if user&.active?
+            "OK"
+          end
+        end
+
+        def voice_connect_event
+          bot.command :connect do |event|
+            @evnt = event
+            if user && !user.active?
+              event.respond error_messages[:account_not_verified]
+            elsif user&.current_chat_id.nil?
+              event.respond error_messages[:no_chat_selected]
+            elsif user&.current_chat_id
+              @chat = Chat.find(user.current_chat_id)
+              voice_connect_checker_action
+              voice_connection_checker_action
+              bot.voice_connect(event.user.voice_channel)
+            else
+              event.respond error_messages[:user_not_logged_in]
+            end
+            "OK"
+          end
+        end
+
+        def voice_disconnect_event
+          bot.command :disconnect do |event|
+            @evnt = event
+            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(" ")
+            @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
+            @visitor = discord_visited?(@evnt.user.id)
+            next if discord_next_action?
+
+            @message = event.message.content
+            @chat = user.current_chat if user
+            private_message_action if user && !chat.nil?
+            "OK"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/discord/validations.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module Validations
+        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
+
+        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 visitor_user?
+          visitor&.dis_user.nil?
+        end
+
+        def valid_for_list_action?
+          evnt.respond(error_messages[:user_not_logged_in]) if user.nil?
+          evnt.respond(error_messages[:account_not_verified]) unless user.active?
+          evnt.respond(error_messages[:chat_not_found]) if user.chats.count.zero? && user.active?
+          !user.nil? && user.active? && user.chats.count.positive?
+        end
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/discord/voice_actions.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module VoiceActions
+        def ask_to_speak_action
+          Message.create(chat_id: chat.id, content: message, role: "user", discord_message_id: evnt.message.id)
+          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
+  end
+end

data/lib/chatgpt_assistant/bots/discord/voice_checkers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  module Bots
+    module Discord
+      module VoiceCheckers
+        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 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
+      end
+    end
+  end
+end

data/lib/chatgpt_assistant/bots/discord_bot.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "discord/bot"
+require_relative "discord/auth"
+require_relative "discord/actions"
+require_relative "discord/chat_actions"
+require_relative "discord/events"
+require_relative "discord/voice_actions"
+require_relative "discord/voice_checkers"
+
+module ChatgptAssistant
+  # This class is responsible to handle the discord bot
+  class DiscordBot < ApplicationBot
+    def start
+      start_event
+      login_event
+      list_event
+      hist_event
+      help_event
+      new_chat_event
+      sl_chat_event
+      ask_event
+      voice_connect_event
+      voice_disconnect_event
+      private_message_event
+      bot_init
+    end
+
+    private
+
+      attr_reader :message
+      attr_accessor :evnt, :user, :chats, :chat
+
+      include Bots::Discord::Bot
+      include Bots::Discord::Auth
+      include Bots::Discord::Actions
+      include Bots::Discord::ChatActions
+      include Bots::Discord::Events
+      include Bots::Discord::VoiceActions
+      include Bots::Discord::VoiceCheckers
+  end
+end

data/lib/chatgpt_assistant/bots/helpers/messenger_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Helper for messenger
+  module MessengerHelper
+    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
+  end
+end

data/lib/{bots → chatgpt_assistant/bots}/jobs/register_job.rb

@@ -9,8 +9,8 @@ module ChatgptAssistant
 
     sidekiq_options queue: :default
 
-    def perform(email, password, chat_id)
-      RegisterService.new(email, password, chat_id).call
+    def perform(email, password, name, chat_id)
+      RegisterService.new(email, password, name, chat_id).call
     end
   end
 end

data/lib/chatgpt_assistant/bots/mailers/account_mailer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "application_mailer"
+
+module ChatgptAssistant
+  # This class is responsible for the register mailer
+  class AccountMailer < ApplicationMailer
+    def register_email(user, token)
+      @user = user
+      @token = token
+      mail(to: user.email, subject: "Welcome to ChatGPT Assistant",
+           content_type: "text/html",
+           body: register_html)
+    end
+
+    private
+
+      attr_reader :user, :token
+
+      def register_html
+        "<h1>Welcome to ChatGPT Assistant</h1> \n
+        <p>Hi #{user.name}</p> \n
+        <p>You are now registered to ChatGPT Assistant</p> \n
+        <p>You can now start using the bot</p> \n
+        <p>To start using the bot, copy and paste the following link in TELEGRAM bot:</p> \n
+        <p>confirm/* #{user.name}:#{token}</p> \n
+        "
+      end
+  end
+end

data/lib/chatgpt_assistant/bots/mailers/application_mailer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Gem module
+module ChatgptAssistant
+  ActionMailer::Base.raise_delivery_errors = true
+  ActionMailer::Base.delivery_method = :smtp
+  ActionMailer::Base.smtp_settings = {
+    address: ENV.fetch("SMTP_ADDRESS", nil),
+    port: ENV.fetch("SMTP_PORT", nil),
+    domain: ENV.fetch("SMTP_DOMAIN", nil),
+    user_name: ENV.fetch("SMTP_USER_NAME", nil),
+    password: ENV.fetch("SMTP_PASSWORD", nil),
+    authentication: ENV.fetch("SMTP_AUTHENTICATION", nil),
+    enable_starttls_auto: ENV.fetch("SMTP_ENABLE_STARTTLS_AUTO", nil) == "true"
+  }
+
+  # This class is responsible for the application mailer
+  class ApplicationMailer < ActionMailer::Base
+    default from: "support@chat.outerspacecoding.com"
+  end
+end