chatgpt_assistant 0.1.4 → 0.1.6

data/lib/chatgpt_assistant/error.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module ChatgptAssistant
+  # Load Error
+  module LoadError
+    def load_error_context
+      language = ENV.fetch("LANGUAGE", "en")
+      discord_prefix = ENV.fetch("DISCORD_PREFIX", "!")
+      DefaultMessages.new(language, discord_prefix).error_messages
+    end
+  end
+
+  # No User Error
+  class NoRegisterInfoError < StandardError
+    def initialize(message = load_error_context[:no_register_info])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Nil Command Error
+  class NilError < StandardError
+    def initialize(message = load_error_context[:nil])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Wrong Email Error
+  class WrongEmailError < StandardError
+    def initialize(message = load_error_context[:wrong_email])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Wrong Password Error
+  class WrongPasswordError < StandardError
+    def initialize(message = load_error_context[:wrong_password])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Already Exists Error
+  class UserAlreadyExistsError < StandardError
+    def initialize(message = load_error_context[:user_already_exists])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Chat Already Exists Error
+  class ChatAlreadyExistsError < StandardError
+    def initialize(message = load_error_context[:chat_already_exists])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Sign Up Error
+  class SignUpError < StandardError
+    def initialize(message = load_error_context[:sign_up_error])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Chat Not Created Error
+  class ChatNotCreatedError < StandardError
+    def initialize(message = load_error_context[:chat_not_created_error])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Message Not Created Error
+  class MessageNotCreatedError < StandardError
+    def initialize(message = load_error_context[:message_not_created_error])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # No Chat Selected Error
+  class NoChatSelectedError < StandardError
+    def initialize(message = load_error_context[:no_chat_selected])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # No Messages Founded Error
+  class NoMessagesFoundedError < StandardError
+    def initialize(message = load_error_context[:no_messages_founded])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # No Chats Founded Error
+  class NoChatsFoundedError < StandardError
+    def initialize(message = load_error_context[:no_chats_founded])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Chat Not Found Error
+  class ChatNotFoundError < StandardError
+    def initialize(message = load_error_context[:chat_not_found])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not Found Error
+  class UserNotFoundError < StandardError
+    def initialize(message = load_error_context[:user_not_found])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not Registered Error
+  class UserNotRegisteredError < StandardError
+    def initialize(message = load_error_context[:user_not_registered])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Logged In Error
+  class UserLoggedInError < StandardError
+    def initialize(message = load_error_context[:user_logged_in])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not Logged In Error
+  class UserNotLoggedInError < StandardError
+    def initialize(message = load_error_context[:user_not_logged_in])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # User Not In Voice Channel Error
+  class UserNotInVoiceChannelError < StandardError
+    def initialize(message = load_error_context[:user_not_in_voice_channel])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Bot Not In Voice Channel Error
+  class BotNotInVoiceChannelError < StandardError
+    def initialize(message = load_error_context[:bot_not_in_voice_channel])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Message Not Found Error
+  class MessageHistoryTooLongError < StandardError
+    def initialize(message = load_error_context[:message_history_too_long])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Text Length Too Long Error
+  class TextLengthTooLongError < StandardError
+    def initialize(message = load_error_context[:text_length_too_long])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Invalid Command Error
+  class InvalidCommandError < StandardError
+    def initialize(message = load_error_context[:invalid_command])
+      super(message)
+    end
+
+    include LoadError
+  end
+
+  # Something Went Wrong Error
+  class SomethingWentWrongError < StandardError
+    def initialize(message = load_error_context[:something_went_wrong])
+      super(message)
+    end
+
+    include LoadError
+  end
+end

data/lib/chatgpt_assistant/migrations.rb

@@ -19,21 +19,6 @@ class VisitorMigration < ActiveRecord::Migration[5.2]
   end
 end
 
-# VisitorActions model
-class VisitorActionsMigration < ActiveRecord::Migration[5.2]
-  def change
-    return if ActiveRecord::Base.connection.table_exists? :visitor_actions
-
-    create_table :visitor_actions do |t|
-      t.references :visitor, null: false, foreign_key: true
-      t.text :action, null: false
-      t.text :description, null: false
-      t.integer :role, null: false, default: 0
-      t.timestamps
-    end
-  end
-end
-
 # User model
 class UserMigration < ActiveRecord::Migration[5.2]
   def change
@@ -56,21 +41,6 @@ class UserMigration < ActiveRecord::Migration[5.2]
   end
 end
 
-# UserActions model
-class UserActionsMigration < ActiveRecord::Migration[5.2]
-  def change
-    return if ActiveRecord::Base.connection.table_exists? :user_actions
-
-    create_table :user_actions do |t|
-      t.references :user, null: false, foreign_key: true
-      t.text :action, null: false, default: ""
-      t.text :description, null: false, default: ""
-      t.integer :role, null: false, default: 0
-      t.timestamps
-    end
-  end
-end
-
 # Chat model
 class ChatMigration < ActiveRecord::Migration[5.2]
   def change
@@ -80,6 +50,9 @@ class ChatMigration < ActiveRecord::Migration[5.2]
       t.references :user, null: false, foreign_key: true
       t.text :title, null: false, default: "", limit: 100
       t.integer :status, null: false, default: 0
+      t.integer :messages_count, null: false, default: 0
+      t.string :actor
+      t.text :prompt
       t.timestamps
     end
   end

data/lib/chatgpt_assistant/models.rb

@@ -5,8 +5,6 @@ require "active_record"
 # Visitor model
 class Visitor < ActiveRecord::Base
   has_many :visitor_actions
-  # has_one :tel_user, foreign_key: "telegram_id", class_name: "User"
-  # has_one :dis_user, foreign_key: "discord_id", class_name: "User"
   validates :name, presence: true
   validates :platform, presence: true
   enum platform: { telegram: 0, discord: 1 }
@@ -20,34 +18,29 @@ class Visitor < ActiveRecord::Base
   end
 end
 
-# VisitorActions model
-class VisitorAction < ActiveRecord::Base
-  belongs_to :visitor
-  validates :action, presence: true
-  validates :description, presence: true
-  validates :role, presence: true
-  enum role: { user: 0, assistant: 1, warning: 2 }
-end
-
 # User model
 class User < ActiveRecord::Base
   attr_accessor :password
 
   belongs_to :tel_visitor, optional: true, foreign_key: "telegram_id", class_name: "Visitor"
   belongs_to :dis_visitor, optional: true, foreign_key: "discord_id", class_name: "Visitor"
-  before_save :encrypt_password
-  validates :email, presence: true, uniqueness: true
-  validates :role, presence: true
-  validates :open_chats, presence: true
-  validates :closed_chats, presence: true
-  validates :total_chats, presence: true
-  validates :total_messages, presence: true
+
+  validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }, length: { maximum: 100 }, on: :create
+  validates :role, presence: true, on: :create
+  validates :open_chats, presence: true, on: :create
+  validates :closed_chats, presence: true, on: :create
+  validates :total_chats, presence: true, on: :create
+  validates :total_messages, presence: true, on: :create
+  validates :password, presence: true, on: :create
+
+  before_save :encrypt_password, if: :password
+
   has_many :chats
 
   def encrypt_password
     return if password.nil?
 
-    self.password_salt = BCrypt::Engine.generate_salt.to_s
+    self.password_salt = BCrypt::Engine.generate_salt
     self.password_hash = BCrypt::Engine.hash_secret(password, password_salt)
   end
 
@@ -62,16 +55,10 @@ class User < ActiveRecord::Base
   def chat_by_title(title)
     chats.find_by(title: title)
   end
-end
 
-# UserActions model
-class UserAction < ActiveRecord::Base
-  belongs_to :user
-  validates :user_id, presence: true
-  validates :action, presence: true
-  validates :description, presence: true
-  validates :role, presence: true
-  enum role: { user: 0, assistant: 1, warning: 2 }
+  def chat_history
+    current_chat.messages.last(10).map { |m| "#{m.role}: #{m.content}\nat: #{m.created_at}" }
+  end
 end
 
 # Chat model
@@ -82,12 +69,20 @@ class Chat < ActiveRecord::Base
 
   belongs_to :user
   has_many :messages
+
+  after_create :init_chat_if_actor_provided
+
+  def init_chat_if_actor_provided
+    return if actor.nil?
+
+    messages.create(content: prompt, role: "system")
+  end
 end
 
 # Message model
 class Message < ActiveRecord::Base
   validates :content, presence: true
-  enum role: { user: 0, assistant: 1 }
+  enum role: { user: 0, assistant: 1, system: 2 }
 
   belongs_to :chat
 end

data/lib/chatgpt_assistant/sidekiq.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "../chatgpt_assistant"
+
+Sidekiq.configure_server do |config|
+  config.redis = { url: ENV.fetch("REDIS_URL", "redis://redis:6379/1") }
+end

data/lib/chatgpt_assistant/sidekiq.yml

@@ -0,0 +1,10 @@
+development:
+  :concurrency: 5
+
+production:
+  :concurrency: 5
+
+:max_retries: 1
+
+:queues:
+  - default

data/lib/chatgpt_assistant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChatgptAssistant
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/lib/chatgpt_assistant.rb

@@ -7,14 +7,18 @@ require_relative "chatgpt_assistant/chatter"
 require_relative "chatgpt_assistant/version"
 require_relative "chatgpt_assistant/config"
 require_relative "chatgpt_assistant/models"
+require_relative "chatgpt_assistant/error"
 require_relative "bots/application_bot"
 require_relative "bots/telegram_bot"
 require_relative "bots/discord_bot"
+require "awesome_chatgpt_actors"
 require "streamio-ffmpeg"
 require "aws-sdk-polly"
 require "telegram/bot"
 require "ibm_watson"
 require "discordrb"
+require "sidekiq"
+require "sidekiq-scheduler"
 require "faraday"
 require "bcrypt"
 
@@ -31,24 +35,12 @@ module ChatgptAssistant
       return discord_bot if discord_mode?
 
       raise "Invalid mode"
-    rescue StandardError => e
-      save_error(e)
-      retry
     end
 
     private
 
       attr_reader :mode, :config
 
-      def save_error(err)
-        puts "Error: #{err.message}"
-        err.backtrace.each { |line| puts line }
-        Error.create(message: err.message, backtrace: err.backtrace) unless err.message == Error.last&.message
-      rescue StandardError
-        puts "Error: #{err.message}"
-        puts "Backtrace: #{err.backtrace}"
-      end
-
       def telegram_mode?
         mode == "telegram"
       end