loggable_activity 0.1.56 → 0.1.58

data/lib/generators/loggable_activity/templates/create_loggable_activities.rb

@@ -1,32 +1,35 @@
 # frozen_string_literal: true
 
-class CreateLoggableActivities < ActiveRecord::Migration[6.1]
+class CreateLoggableActivities < ActiveRecord::Migration[7.1]
   def change
+    create_table :loggable_data_owners do |t|
+      t.references :record, polymorphic: true, null: true, index: true
+      t.references :encryption_key, null: false, foreign_key: { to_table: 'loggable_encryption_keys' }
+    end
+
     create_table :loggable_activities do |t|
       t.string :action
       t.references :actor, polymorphic: true, null: true
-      t.string :encrypted_actor_display_name
-      t.string :encrypted_record_display_name
+      t.string :encrypted_actor_name
       t.references :record, polymorphic: true, null: true
-
       t.timestamps
     end
 
     create_table :loggable_payloads do |t|
-      t.references :record, polymorphic: true, null: true
+      t.references :activity, null: false, foreign_key: { to_table: 'loggable_activities' }
+      t.references :encryption_key, null: false, foreign_key: { to_table: 'loggable_encryption_keys' }
+      t.references :record, polymorphic: true, null: true, index: true
+      t.string :encrypted_record_name
       t.json :encrypted_attrs
-      t.integer :payload_type, default: 0
+      t.integer :related_to_activity_as, default: 0
       t.boolean :data_owner, default: false
-      t.string :route, default: nil
-      t.references :activity, foreign_key: { to_table: 'loggable_activities', class_name: 'LoggableActivity::Activity' }
-
-      t.timestamps
+      t.string :route
+      t.boolean :current_payload, default: true
     end
 
     create_table :loggable_encryption_keys do |t|
-      t.references :parent_key, foreign_key: { to_table: 'loggable_encryption_keys', on_delete: :nullify }
-      t.string :key
-      t.references :record, polymorphic: true, on_delete: :nullify
+      t.references :record, polymorphic: true, null: true, index: true
+      t.string :secret_key
     end
   end
 end

data/lib/loggable_activity/activity.rb

@@ -7,9 +7,9 @@ module LoggableActivity
   class Activity < ActiveRecord::Base
     self.table_name = 'loggable_activities'
     # Associations
-    has_many :payloads, class_name: 'LoggableActivity::Payload', dependent: :destroy
-    belongs_to :record, polymorphic: true, optional: true
+    has_many :payloads, class_name: '::LoggableActivity::Payload', dependent: :destroy
     belongs_to :actor, polymorphic: true, optional: true
+    belongs_to :record, polymorphic: true, optional: true
 
     accepts_nested_attributes_for :payloads
 
@@ -22,7 +22,7 @@ module LoggableActivity
     #
     # Each hash in the array contains:
     # - :record_type: The class name of the record.
-    # - :payload_type: A descriptor of the payload's role (e.g., 'primary_payload' or 'current_association').
+    # - :related_to_activity_as: A descriptor of the payload's role (e.g., 'primary_payload' or 'current_association').
     # - :attrs: A hash of the record's attributes.
     #
     # Example usage:
@@ -30,65 +30,36 @@ module LoggableActivity
     #
     # Sample return value:
     #   [
-    #     { record_type: MODEL_NAME, payload_type: "primary_payload", attrs: { "KEY" => "VALUE", ... } },
-    #     { record_type: MODEL_NAME, payload_type: "current_association", attrs: { "KEY" => "VALUE", ... } },
+    #     { record_type: MODEL_NAME, related_to_activity_as: "primary_payload", attrs: { "KEY" => "VALUE", ... } },
+    #     { record_type: MODEL_NAME, related_to_activity_as: "current_association", attrs: { "KEY" => "VALUE", ... } },
     #     ...
     #   ]
     def attrs
+      {
+        actor_type:,
+        actor_id:,
+        action:,
+        actor_display_name:,
+        record_display_name:,
+        payloads: payloads_attrs
+      }
+    end
+
+    def payloads_attrs
       ordered_payloads.map do |payload|
         {
+          related_to_activity_as: payload.related_to_activity_as,
           record_type: payload.record_type,
-          record_id: payload.record_id,
-          payload_type: payload.payload_type,
+          record_id: payload.deleted? ? nil : payload.record_id,
           attrs: payload.attrs,
-          route: payload.payload_route
+          route: payload.payload_route,
+          record_display_name: payload.record_display_name,
+          current_payload: payload.current_payload,
+          data_owner: payload.data_owner
         }
       end
     end
 
-    # Returns a hash describing the attributes of an update activity, including updated attributes for a record and any updated related attributes.
-    #
-    # Example:
-    #   @activity.update_activity_attrs
-    #
-    # The return value is structured as follows:
-    # - :update_attrs contains the attributes of the record being updated, detailing changes from previous to new values.
-    # - :updated_relations_attrs is an array of hashes, each representing an updated related record. Each hash details the previous and current attributes of the relation.
-    #
-    # Example Return Structure:
-    #   {
-    #     update_attrs: {
-    #       record_class: "CLASS.NAME",
-    #       attrs: [{ "KEY" => { from: "OLD_VALUE", to: "NEW_VALUE" } }]
-    #     },
-    #     updated_relations_attrs: [
-    #       {
-    #         record_class: "CLASS.NAME",
-    #         previous_attrs: { attrs: { "KEY" => "VALUE", ... } },
-    #         current_attrs: { attrs: { "KEY" => "VALUE", ... } }
-    #       }
-    #     ]
-    #   }
-    def update_activity_attrs
-      {
-        update_attrs:,
-        updated_relations_attrs:
-      }
-    end
-    
-    # Returns the attributes for the primary payload, without the relations.
-    #
-    # Example:
-    #
-    #   @activity.primary_payload_attrs
-    #
-    # Returns:
-    #   { "KEY_A" => "VALUE_A", "KEY_B" => "VALUE_B", ... }
-    #
-    def primary_payload_attrs
-      primary_payload ? primary_payload.attrs : {}
-    end
-
     # Returns the attributes for the relations.
     #
     # Example:
@@ -100,13 +71,13 @@ module LoggableActivity
     #     {
     #       record_type: CLASS.NAME,
     #       record_id: INTEGER,
-    #       payload_type: ENUM 
+    #       related_to_activity_as: ENUM
     #       attrs: { "KEY_A" => "VALUE_A", "KEY_B" => "VALUE_B", ... }
     #     }
     #   ]
-    def relations_attrs
-      attrs.filter { |p| p[:payload_type] == 'current_association' }
-    end
+    # def relations_attrs
+    #   attrs.filter { |p| p[:related_to_activity_as] == 'current_association' }
+    # end
 
     # Returns the display name for a record. what method to use if defined in '/config/loggable_activity.yaml'
     #
@@ -118,9 +89,7 @@ module LoggableActivity
     #   "David Bowie"
     #
     def record_display_name
-      return I18n.t('loggable.activity.deleted') if encrypted_record_display_name.nil?
-
-      LoggableActivity::Encryption.decrypt(encrypted_record_display_name, record_key)
+      primary_payload.record_display_name
     end
 
     # Returns the path for the activity.
@@ -132,8 +101,8 @@ module LoggableActivity
     # Returns:
     #   "/path/to/activity"
     #
-    def primary_route 
-      primary_payload&.payload_route
+    def primary_route
+      primary_payload.payload_route
     end
 
     # Returns the display name for a actor. what method to use if defined in '/config/loggable_activity.yaml'
@@ -146,28 +115,30 @@ module LoggableActivity
     #   "Elvis Presley"
     #
     def actor_display_name
-      return I18n.t('loggable.activity.deleted') if encrypted_actor_display_name.nil?
+      return I18n.t('loggable.activity.deleted') if actor_deleted?
 
-      LoggableActivity::Encryption.decrypt(encrypted_actor_display_name, actor_key)
+      ::LoggableActivity::Encryption.decrypt(encrypted_actor_name, actor_secret_key)
     end
 
     # Returns a list of activities for a given actor.
     def self.activities_for_actor(actor, limit = 20, params = { offset: 0 })
-      LoggableActivity::Activity.latest(limit, params).where(actor:)
+      ::LoggableActivity::Activity.latest(limit, params).where(actor:)
     end
 
     # Returns a list of activities ordered by creation date.
+    # This is done to support UUID primary keys.
     def self.latest(limit = 20, params = { offset: 0 })
       offset = params[:offset] || 0
-      LoggableActivity::Activity
+      ::LoggableActivity::Activity
         .all
         .order(created_at: :desc)
-        .includes(:payloads)
+        .includes(payloads: :encryption_key)
         .offset(offset)
         .limit(limit)
     end
 
     # Returns the last activity.
+    # This is done to support of UUID primary keys.
     def self.last(limit = 1)
       return latest(1).first if limit == 1
 
@@ -180,57 +151,37 @@ module LoggableActivity
     #
     # Example usage:
     #   payload = @activity.primary_payload
-    #   puts payload.record_type  # => 'SOMD_MODEL_NAME'
+    #   payload.record_type  # => 'SOMD_MODEL_NAME'
     #
     def primary_payload
-      ordered_payloads.find { |p| p.payload_type == 'primary_payload' }
+      related_to_activity_as = %w[primary_payload primary_update_payload primary_destroy_payload]
+      payloads.detect { |p| related_to_activity_as.include?(p.related_to_activity_as) }
     end
 
-    # Returns the attributes for the update+payload.
-    def update_attrs
-      update_payload_attrs = attrs.find { |p| p[:payload_type] == 'update_payload' }
-      return nil unless update_payload_attrs
-
-      update_payload_attrs.delete(:payload_type)
-      update_payload_attrs
-    end
-
-
-    # Returns the attributes for the updated relations.
-    def updated_relations_attrs
-      grouped_associations = attrs.group_by { |p| p[:record_type] }
-
-      grouped_associations.map do |record_type, payloads|
-        previous_attrs = payloads.find { |p| p[:payload_type] == 'previous_association' }
-        current_attrs = payloads.find { |p| p[:payload_type] == 'current_association' }
-        next if previous_attrs.nil? && current_attrs.nil?
-
-        { record_type:, previous_attrs:, current_attrs: }
-      end.compact
-    end
-
-    # Returns the previous association attributes.
-    def previous_associations_attrs
-      attrs.select { |p| p[:payload_type] == 'previous_association' }
-    end
-
-    # Returns payloads sorted by :payload_type.
+    # # Returns payloads sorted by :related_to_activity_as.
     def ordered_payloads
-      payloads.order(:payload_type)
+      # payloads.order(related_to_activity_as: :desc)
+      payloads
     end
 
     # Returns the key for the logged record.
     def record_key
       return nil if record.nil?
 
-      LoggableActivity::EncryptionKey.for_record(record)&.key
+      ::LoggableActivity::EncryptionKey.for_record(record)&.secret_key
     end
 
-    # Returns the key for the actor.
-    def actor_key
-      return nil if actor.nil?
+    # Check if the actor is deleted.
+    # If the actor is deleted, it will return true.
+    # This way we don't rely on access to the main DB to check if the actor is deleted.
+    def actor_deleted?
+      actor_secret_key.nil?
+    end
 
-      LoggableActivity::EncryptionKey.for_record(actor)&.key
+    # Returns the key for the actor.
+    def actor_secret_key
+      # @actor_key_secret_key ||=
+      ::LoggableActivity::EncryptionKey.for_record_by_type_and_id(actor_type, actor_id)&.secret_key
     end
 
     # Validates that the activity has at least one payload.

data/lib/loggable_activity/configuration.rb

@@ -1,20 +1,66 @@
 # frozen_string_literal: true
 
+require 'json-schema'
+require 'json'
+
 module LoggableActivity
   # This class is used to load the configuration file located at config/loggable_activity.yml
+  class ConfigurationError < StandardError
+    def initialize(msg = '')
+      # https://api.loggable_activity.com/msg
+      puts '---------------- LOGGABLE ACTIVITY -----------------'
+      puts msg
+      puts '----------------------------------------------------'
+      super(msg)
+    end
+  end
+
+  # This class is used to load the configuration file located at config/loggable_activity.yml
+  # When the LoggableActivity::Hook is included in a model
+  # it takes the model's name and find the configuration for that model in the configuration file.
   class Configuration
     # Loads the configuration file
     def self.load_config_file(config_file_path)
       @config_data = YAML.load_file(config_file_path)
+      validate_config_file
+    rescue Errno::ENOENT
+      raise ConfigurationError, 'config/loggable_activity.yaml not found'
+    end
+
+    # Loads the schema file for the configuration file
+    def self.load_schema
+      schema_path = File.join(__dir__, '..', 'schemas', 'config_schema.json')
+      JSON.parse(File.read(schema_path))
+    end
+
+    # Validates the configuration file againss the schema
+    def self.validate_config_file
+      schema = load_schema
+      errors = JSON::Validator.fully_validate(schema, @config_data)
+      return unless errors.any?
+
+      raise ConfigurationError,
+            "config/loggable_activity.yaml is invalid: #{errors.join(', ')}"
+    end
+
+    # Returns true if the configuration file has been loaded
+    def self.loaded?
+      !@config_data.nil?
+    end
+
+    # Returns the configuration data
+    class << self
+      # @return [Hash]
+      attr_reader :config_data
     end
 
     # Returns the configuration data for the given class
     #
     # Example:
-    #   LoggableActivity::Configuration.for_class('User')
+    #   ::LoggableActivity::Configuration.for_class('User')
     # Returns:
     #   {
-    #     "record_display_name": "full_name",
+    #     "fetch_record_name_from": "full_name",
     #     "loggable_attrs": [
     #       "first_name",
     #       "last_name",
@@ -23,10 +69,21 @@ module LoggableActivity
     #       "create",
     #       "update",
     #       "destroy"
-    #     ]
+    #     ],
+    #   ....
     #   }
     def self.for_class(class_name)
       @config_data[class_name]
     end
+
+    # Returns the name of the field or method to use for the actor's display name.
+    def self.fetch_current_user_name_from
+      @config_data['fetch_current_user_name_from']
+    end
+
+    # Returns the name of the model to use for the current user.
+    def self.current_user_model_name
+      @config_data['current_user_model_name']
+    end
   end
 end

data/lib/loggable_activity/data_owner.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module LoggableActivity
+  # This class represends an additional data owner for a record.
+  # For it to kick in, the data_owner configuration has to be set to true in the loggable_activity.yaml file.
+  class DataOwner < ActiveRecord::Base
+    self.table_name = 'loggable_data_owners'
+    belongs_to :record, polymorphic: true, optional: true
+    belongs_to :encryption_key, class_name: '::LoggableActivity::EncryptionKey'
+
+    # When a record is deleted, all data owner added to the record is also deleted.
+    def mark_as_deleted!
+      encryption_key.mark_as_deleted!
+    end
+  end
+end

data/lib/loggable_activity/encryption.rb

@@ -5,24 +5,21 @@ require 'openssl'
 require 'base64'
 
 module LoggableActivity
-  # This error is raised when encryption or decryption fails
-  class EncryptionError < StandardError
-  end
-
   # This module is used to encrypt and decrypt attributes
   module Encryption
     # Encrypts the given data using the given encryption key
     #
     # Example:
-    #   LoggableActivity::Encryption.encrypt('my secret data', 'my secret key')
+    #   ::LoggableActivity::Encryption.encrypt('my secret data', 'my secret key')
     #
     # Returns:
     #   "SOME_ENCRYPTED_STRING"
     #
-    def self.encrypt(data, encoded_key)
-      return nil if data.nil? || encoded_key.nil?
+    def self.encrypt(data, secret_key)
+      return nil if secret_key.nil?
+      return nil if data.nil?
 
-      encryption_key = Base64.decode64(encoded_key)
+      encryption_key = Base64.decode64(secret_key)
       raise EncryptionError, "Encryption failed: Invalid encoded_key length #{encryption_key.bytesize}" unless encryption_key.bytesize == 32
 
       cipher = OpenSSL::Cipher.new('AES-256-CBC').encrypt
@@ -39,19 +36,21 @@ module LoggableActivity
     # Decrypts the given data using the given encryption key
     #
     # Example:
-    #   LoggableActivity::Encryption.decrypt('SOME_ENCRYPTED_STRING', 'SECRET_KEY')
+    #   ::LoggableActivity::Encryption.decrypt('SOME_ENCRYPTED_STRING', 'SECRET_KEY')
     #
     # Returns:
     #   "my secret data"
     #
-    def self.decrypt(data, encoded_key)
-      return '' if data.nil? || encoded_key.nil?
+    def self.decrypt(data, secret_key)
+      return I18n.t('loggable.activity.deleted') if secret_key.nil?
+      return '' if data.blank?
 
-      encryption_key = Base64.decode64(encoded_key)
+      encryption_key = Base64.decode64(secret_key)
       raise EncryptionError, "Decryption failed: Invalid encoded_key length: #{encryption_key.bytesize}" unless encryption_key.bytesize == 32
 
       cipher = OpenSSL::Cipher.new('AES-256-CBC').decrypt
       cipher.key = encryption_key
+      raise EncryptionError, 'Decryption failed: Invalid data length' unless data.bytesize > cipher.iv_len
 
       raw_data = Base64.decode64(data)
       cipher.iv = raw_data[0...cipher.iv_len] # Extract IV from the beginning of raw_data
@@ -59,9 +58,10 @@ module LoggableActivity
 
       decrypted_data.force_encoding('UTF-8')
     rescue OpenSSL::Cipher::CipherError => e
-      raise EncryptionError, "Decryption failed: #{e.message}"
+      puts "CipherError Decryption failed: #{e.message}"
+      '*** DECRYPTION FAILED ***'
     rescue EncryptionError => e
-      puts e.message
+      puts "EncryptionError failed: #{e.message}"
       '*** DECRYPTION FAILED ***'
     end
 

data/lib/loggable_activity/encryption_key.rb

@@ -10,24 +10,29 @@ module LoggableActivity
 
     # Associations
     belongs_to :record, polymorphic: true, optional: true
-    belongs_to :parent_key, class_name: 'LoggableActivity::EncryptionKey', optional: true,
-                            foreign_key: 'parent_key_id'
+    # belongs_to :payload, class_name: '::LoggableActivity::Payload', optional: true
+    # belongs_to :parent_key, class_name: '::LoggableActivity::EncryptionKey', optional: true,
+    # foreign_key: 'parent_key_id'
 
     # Marks the encryption key as deleted by updating the key to nil.
-    def mark_as_deleted
-      update(key: nil)
-      parent_key.mark_as_deleted if parent_key.present?
+    def mark_as_deleted!
+      update(secret_key: nil)
+    end
+
+    # check if the encryption key is deleted
+    def deleted?
+      secret_key.nil?
     end
 
     # Returns an encryption key for a record by its type and ID, optionally using a parent key.
     #
     #  @param record_type [String] The type of the record.
     #  @param record_id [Integer] The ID of the record.
-    #  @param parent_key [LoggableActivity::EncryptionKey, nil] The parent encryption key, if any.
-    #  @return [LoggableActivity::EncryptionKey] The encryption key for the record.
+    #  @param parent_key [::LoggableActivity::EncryptionKey, nil] The parent encryption key, if any.
+    #  @return [::LoggableActivity::EncryptionKey] The encryption key for the record.
     #
     # Example:
-    #  LoggableActivity::EncryptionKey.for_record_by_type_and_id('User', 1)
+    #  ::LoggableActivity::EncryptionKey.for_record_by_type_and_id('User', 1)
     #
     # Returns:
     #  {
@@ -38,22 +43,22 @@ module LoggableActivity
     #    :record_id => 1
     #  }
     #
-    def self.for_record_by_type_and_id(record_type, record_id, parent_key = nil)
+    def self.for_record_by_type_and_id(record_type, record_id)
       encryption_key = find_by(record_type:, record_id:)
       return encryption_key if encryption_key
 
-      create_encryption_key(record_type, record_id, parent_key)
+      create_encryption_key(record_type, record_id)
     end
 
     # Returns an encryption key for a record, optionally using a parent key.
     #
     #  @param record [ActiveRecord::Base] The record for which to get the encryption key.
-    #  @param parent_key [LoggableActivity::EncryptionKey, nil] The parent encryption key, if any.
-    #  @return [LoggableActivity::EncryptionKey] The encryption key for the record.
+    #  @param parent_key [::LoggableActivity::EncryptionKey, nil] The parent encryption key, if any.
+    #  @return [::LoggableActivity::EncryptionKey] The encryption key for the record.
     #
     # Example:
     #  user = User.find(1)
-    #  LoggableActivity::EncryptionKey.for_record(user)
+    #  ::LoggableActivity::EncryptionKey.for_record(user)
     #
     # Returns:
     #  {
@@ -64,24 +69,24 @@ module LoggableActivity
     #    :record_id => 1
     #  }
     #
-    def self.for_record(record, parent_key = nil)
+    def self.for_record(record)
       return nil if record.nil?
 
       encryption_key = find_by(record:)
       return encryption_key if encryption_key
 
-      create_encryption_key(record.class.name, record.id, parent_key)
+      create_encryption_key(record.class.name, record.id)
     end
 
     # Creates an encryption key for a record, optionally using a parent key.
     #
     #  @param record_type [String] The type of the record.
     #  @param record_id [Integer] The ID of the record.
-    #  @param parent_key [LoggableActivity::EncryptionKey, nil] The parent encryption key, if any.
-    #  @return [LoggableActivity::EncryptionKey] The created encryption key.
+    #  @param parent_key [::LoggableActivity::EncryptionKey, nil] The parent encryption key, if any.
+    #  @return [::LoggableActivity::EncryptionKey] The created encryption key.
     #
     # Example:
-    #  LoggableActivity::EncryptionKey.create_encryption_key('User', 1)
+    #  ::LoggableActivity::EncryptionKey.create_encryption_key('User', 1)
     #
     # Returns:
     #  {
@@ -92,12 +97,8 @@ module LoggableActivity
     #    :record_id => 1
     #  }
     #
-    def self.create_encryption_key(record_type, record_id, parent_key = nil)
-      if parent_key
-        create(record_type:, record_id:, key: random_key, parent_key:)
-      else
-        create(record_type:, record_id:, key: random_key)
-      end
+    def self.create_encryption_key(record_type, record_id)
+      create(record_type:, record_id:, secret_key: random_key)
     end
 
     # Generates a random encryption key.
@@ -105,7 +106,7 @@ module LoggableActivity
     #  @return [String] The generated encryption key.
     #
     # Example:
-    #  LoggableActivity::EncryptionKey.random_key
+    #  ::LoggableActivity::EncryptionKey.random_key
     #
     # Returns:
     #  "a8f4774e7f42eb253045a4db7de7b79e"

data/lib/loggable_activity/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LoggableActivity
+  # Error class for loggable activity.
+  class Error < StandardError
+    def initialize(msg = '')
+      puts '---------------- LOGGABLE ACTIVITY -----------------'
+      puts msg
+      puts '----------------------------------------------------'
+      super(msg)
+    end
+  end
+
+  # Error class for encryption.
+  class EncryptionError < StandardError
+    def initialize(msg = '')
+      puts '---------------- LOGGABLE ACTIVITY -----------------'
+      puts msg
+      puts '----------------------------------------------------'
+      super(msg)
+    end
+  end
+
+  # This class is used to load the configuration file located at config/loggable_activity.yml
+  class ConfigurationError < StandardError
+    def initialize(msg = '')
+      # https://api.loggable_activity.com/msg
+      puts '---------------- LOGGABLE ACTIVITY -----------------'
+      puts msg
+      puts '----------------------------------------------------'
+      super(msg)
+    end
+  end
+end