loggable_activity 0.1.56 → 0.1.58

data/lib/loggable_activity/hooks.rb

@@ -2,30 +2,31 @@
 
 require 'active_support/concern'
 
-# This is the main module for loggable.
-# When included to a model, it provides the features for creating the activities.
-require 'loggable_activity/payloads_builder'
-require 'loggable_activity/update_payloads_builder'
-
 module LoggableActivity
   # This module provides hooks for creating activities when included in a model.
+  # When included to a model, it provides the features for logging events regarding to the model.
+  # For this to work you have to update the configuration file 'config/loggable_activity.yaml
+
+  # When included to a model, it provides the features for logging events regarding to the model.
+  # For this to work you have to update the configuration file 'config/loggable_activity.yaml
   module Hooks
     extend ActiveSupport::Concern
-    include LoggableActivity::PayloadsBuilder
-    include LoggableActivity::UpdatePayloadsBuilder
+    # The disable_hooks attribute is used to disable hooks when a model is created or updated by a parent model.
+    attr_accessor :disable_hooks
 
     # The included hook sets up configuration and callback hooks for the model.
     included do
-      config = LoggableActivity::Configuration.for_class(name)
+      config = ::LoggableActivity::Configuration.for_class(name)
 
-      raise "Loggable::Configuration not found for #{name}, Please add it to 'config/loggable_activity.yaml'" if config.nil?
+      if config.nil?
+        raise LoggableActivity::Error, "Configuration not found for #{name}, Please add it to 'config/loggable_activity.yaml"
+      end
 
       # Initializes attributes based on configuration.
       self.loggable_attrs = config&.fetch('loggable_attrs', []) || []
       self.relations = config&.fetch('relations', []) || []
       self.auto_log = config&.fetch('auto_log', []) || []
-      self.actor_display_name = config&.fetch('actor_display_name', nil)
-      self.record_display_name = config&.fetch('record_display_name', nil)
+      self.fetch_record_name_from = config&.fetch('fetch_record_name_from', nil)
       self.route = config&.fetch('route', nil)
 
       after_create :log_create_activity
@@ -41,9 +42,7 @@ module LoggableActivity
     def log(action, actor: nil, params: {})
       @action = action
       @actor = actor || Thread.current[:current_user]
-      # LoggableActivity::EncryptionKey.for_record(self)
-
-      return if @actor.nil?
+      return nil if @actor.nil?
 
       @record = self
       @params = params
@@ -80,21 +79,38 @@ module LoggableActivity
 
     # Creates an activity with the specified payloads.
     def create_activity(payloads)
-      return if nothing_to_log?(payloads)
+      return nil if nothing_to_log?(payloads)
 
-      LoggableActivity::Activity.create!(
-        encrypted_actor_display_name: encrypted_actor_name,
-        encrypted_record_display_name: encrypted_record_name,
+      ::LoggableActivity::Activity.create!(
+        encrypted_actor_name:,
         action: action_key,
         actor: @actor,
-        record: @record,
+        record: self,
         payloads:
       )
     end
 
+    # Builds update payloads for the current action.
+    def build_update_payloads
+      ::LoggableActivity::Services::UpdatePayloadsBuilder
+        .new(self, @payloads).build
+    end
+
+    # Builds payloads for the current action.
+    def build_payloads
+      ::LoggableActivity::Services::PayloadsBuilder
+        .new(self, @payloads).build
+    end
+
+    # Builds destroy payloads for the current action.
+    def build_destroy_payload
+      ::LoggableActivity::Services::DestroyPayloadsBuilder
+        .new(self, @payloads).build
+    end
+
     # Returns true if there are no payloads to log.
-    def nothing_to_log?(payloads)
-      payloads.empty?
+    def nothing_to_log?(_payloads)
+      @payloads.empty?
     end
 
     # Logs a custom activity.
@@ -102,60 +118,78 @@ module LoggableActivity
 
     # Logs an update activity automatically if configured.
     def log_update_activity
+      return unless hooks_enabled?
+
       log(:update) if self.class.auto_log.include?('update')
     end
 
+    # Hooks can disabled when a model is created or updated
+    # by a parrent model.
+    def hooks_enabled?
+      enabled = disable_hooks.nil? || disable_hooks == false
+      self.disable_hooks = false
+      enabled
+    end
+
     # Logs a create activity automatically if configured.
     def log_create_activity
+      return unless hooks_enabled?
+
       log(:create) if self.class.auto_log.include?('create')
     end
 
     # Logs a destroy activity automatically if configured.
     def log_destroy_activity
-      LoggableActivity::EncryptionKey.for_record(self)&.mark_as_deleted
+      mark_encryption_keys_as_deleted
+      return unless hooks_enabled?
+
       log(:destroy) if self.class.auto_log.include?('destroy')
     end
 
+    # Fullfill the needs of the data owners.
+    # Mostly this will be performend a few one, from 1 to 5.
+    # Enumeration for different payload relation types
+    def mark_encryption_keys_as_deleted
+      ::LoggableActivity::EncryptionKey.for_record(self)&.mark_as_deleted!
+      # data_owners = ::LoggableActivity::DataOwner.where(record: self)
+      ::LoggableActivity::DataOwner
+        .where(record: self)
+        .each(&:mark_as_deleted!)
+    end
+
     # Returns the encrypted name of the actor.
     def encrypted_actor_name
-      actor_display_name = @actor.send(actor_display_name_field)
-      LoggableActivity::Encryption.encrypt(actor_display_name, actor_encryption_key)
+      name = @actor.send(fetch_current_user_name_from)
+      ::LoggableActivity::Encryption.encrypt(name, actor_secret_key)
     end
 
-    # Returns the encrypted name of the record.
-    def encrypted_record_name
-      display_name =
-        if self.class.record_display_name.nil?
-          "#{self.class.name} id: #{id}"
-        else
-          send(self.class.record_display_name.to_sym)
-        end
-      LoggableActivity::Encryption.encrypt(display_name, primary_encryption_key)
+    # Reads the field to feetch the record name from.
+    def fetch_current_user_name_from
+      ::LoggableActivity::Configuration.fetch_current_user_name_from
     end
 
     # Returns the action key for the current action.
     def action_key
-      @action_key ||= self.class.base_action + ".#{@action}"
+      self.class.base_action + ".#{@action}"
     end
 
     # Returns the primary encryption key for the activity
     def primary_encryption_key
-      @primary_encryption_key ||=
-        LoggableActivity::EncryptionKey.for_record(self)&.key
+      encryption_key_for_record
     end
 
-    # Returns true if the primary encryption key is deleted.
-    def primary_encryption_key_deleted?
-      primary_encryption_key.nil?
+    # Returns the encryption key for the record.
+    def encryption_key_for_record(record = @record)
+      ::LoggableActivity::EncryptionKey.for_record(record)
     end
 
     # Returns the encryption key for the actor.
-    def actor_encryption_key
-      LoggableActivity::EncryptionKey.for_record(@actor)&.key
+    def actor_secret_key
+      encryption_key_for_record(@actor)&.secret_key
     end
 
     # Returns the display name of the actor.
-    def actor_display_name_field
+    def actor__name_field
       Rails.application.config.loggable_activity.actor_display_name || "id: #{@actor.id}, class: #{@actor.class.name}"
     end
 
@@ -165,7 +199,8 @@ module LoggableActivity
     end
 
     class_methods do
-      attr_accessor :loggable_attrs, :relations, :auto_log, :actor_display_name, :record_display_name, :route
+      # The loggable_attrs attribute is used read the configuration for the model that included LoggableActivity::Hooks.
+      attr_accessor :loggable_attrs, :relations, :auto_log, :fetch_record_name_from, :route
 
       # Convert the model name and name space in to 'base_action'.
       def base_action

data/lib/loggable_activity/payload.rb

@@ -8,23 +8,50 @@ module LoggableActivity
   # Payloads come in different types, each serving a specific purpose.
   class Payload < ActiveRecord::Base
     self.table_name = 'loggable_payloads'
+    validates :related_to_activity_as, presence: true
 
     # Associations
     belongs_to :activity
+    belongs_to :encryption_key, class_name: '::LoggableActivity::EncryptionKey'
     belongs_to :record, polymorphic: true, optional: true
 
+    # Enumeration for different payload types
+    DECRYPT_ATTRS_TYPES = %w[
+      primary_payload
+      has_many_payload
+      belongs_to_payload
+      has_one_payload
+      belongs_to_update_payload
+      has_many_create_payload
+    ].freeze
+
+    # Enumeration for different updatepayload types
+    DECRYPT_UPDATE_ATTRS_TYPES = %w[
+      primary_update_payload
+      has_one_update_payload
+      has_many_update_payload
+    ].freeze
     # Validations
     validates :encrypted_attrs, presence: true
 
-    # Enumeration for different payload types
-    enum payload_type: {
+    # Enumeration for different payload relation types
+    enum related_to_activity_as: {
       primary_payload: 0,
-      update_payload: 1,
-      current_association: 2,
-      previous_association: 3
+      has_one_payload: 1,
+      belongs_to_payload: 2,
+      has_many_payload: 3,
+      primary_destroy_payload: 4,
+      primary_update_payload: 5,
+      has_one_update_payload: 6,
+      has_many_update_payload: 7,
+      has_many_create_payload: 8,
+      belongs_to_update_payload: 9,
+      belongs_to_destroy_payload: 10,
+      has_one_destroy_payload: 11,
+      has_many_destroy_payload: 12
     }
 
-    # Returns the decrypted attributes of the payload based on its type.
+    # Returns the decrypted attrs.
     #
     # @return [Hash] The decrypted attributes.
     #
@@ -32,38 +59,59 @@ module LoggableActivity
     #  payload.attrs
     #
     #  Returns:
-    #  {
-    #           "street" => "Machu Picchu",
-    #             "city" => "Aguas Calientes",
-    #          "country" => "Peru",
-    #      "postal_code" => "08680"
-    #  }
+    #  { "street" => "Machu Picchu", "city" => "Cusco" }
     #
     def attrs
       return deleted_attrs if record.nil?
 
-      case payload_type
-      when 'current_association', 'primary_payload', 'previous_association'
+      case related_to_activity_as
+      when *DECRYPT_ATTRS_TYPES
         decrypted_attrs
-      when 'update_payload'
+      when *DECRYPT_UPDATE_ATTRS_TYPES
         decrypted_update_attrs
+      else
+        {}
       end
     end
 
-    # Returns the route for the payload.
+    # Returns the route for the payload unless the encryption_key is deleted.
+    #
+    # Example:
+    #   payload.payload_route
+    #
+    # @return [String] The route for the payload.
     def payload_route
-      return nil if payload_encryption_key.nil?
+      return '' if deleted?
 
       route
     end
 
+    # Returns the display name for the record.
+    #
+    # Example:
+    #   payload.record_display_name
+    #
+    # @return [String] The display name for the record.
+    def record_display_name
+      return I18n.t('loggable.activity.deleted') if deleted?
+
+      ::LoggableActivity::Encryption.decrypt(encrypted_record_name, secret_key)
+    end
+
+    # Check if the record has been deleted.
+    #
+    # @return [Boolean] True if the record has been deleted.
+    def deleted?
+      encryption_key.deleted?
+    end
+
     private
 
     # Retrieves the encryption key for the payload.
     #
     # @return [String, nil] The encryption key.
-    def payload_encryption_key
-      @payload_encryption_key ||= LoggableActivity::EncryptionKey.for_record(record)&.key
+    def secret_key
+      encryption_key.secret_key
     end
 
     # Helper method to handle deleted attributes.
@@ -77,6 +125,7 @@ module LoggableActivity
     #
     # @return [Array<Hash>] The array of decrypted changes.
     def decrypted_update_attrs
+      # return encrypted_attrs
       encrypted_attrs['changes'].map do |change|
         decrypted_from_to_attr(change)
       end
@@ -108,7 +157,8 @@ module LoggableActivity
     # @param value [String] The encrypted value to decrypt.
     # @return [String] The decrypted value.
     def decrypt_attr(value)
-      LoggableActivity::Encryption.decrypt(value, payload_encryption_key)
+      # return 'loggable_activity.attr.deleted' if secret_key.nil?
+      ::LoggableActivity::Encryption.decrypt(value, secret_key)
     end
   end
 end

data/lib/loggable_activity/services/base_payloads_builder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module LoggableActivity
+  module Services
+    # This service class provides the base payloads builder for the loggable activity.
+    # Other service modules related to the loggable activity will inherit from this module.
+    class BasePayloadsBuilder
+      # Initializes the PayloadsBuilder with a record and an initial collection of payloads,
+      def initialize(record, payloads)
+        @record = record
+        @payloads = payloads
+        @loggable_attrs = record.class.loggable_attrs
+        # @relation_config = record.relation_config
+        @relations = record.class.relations
+        @auto_log = record.class.auto_log
+        # @fetch_record_name_from = record.class.fetch_record_name_from
+        @route = record.class.route
+      end
+
+      private
+
+      # Returns saved changes for a record.
+      def saved_changes(record)
+        [record.saved_changes.transform_values(&:first), record.saved_changes.transform_values(&:last)]
+      end
+
+      # Fetch the previous and current values for a record.
+      def changes_to_save(record)
+        changes = record.changes_to_save
+        previous_values = {}
+        current_values = {}
+
+        changes.map do |key, value|
+          previous_values[key] = value[0]
+          current_values[key] = value[1]
+        end
+        [previous_values, current_values]
+      end
+
+      # Encrypts the record name for the record.
+      # If the record has a fetch_record_name_from the configuration,
+      # it will use that method to fetch the record name.
+      # Otherwise, it will use the class name and the record id.
+      def encrypt_record_name_for_record(record, secret_key)
+        record_name = fetch_record_name_for_record(record) || "#{record.class.name}##{record.id}"
+
+        ::LoggableActivity::Encryption.encrypt(record_name, secret_key)
+      end
+
+      # Return the record name for the record.
+      # If the record has a fetch_record_name_from the configuration,
+      def fetch_record_name_for_record(record)
+        fetch_from = record.class.fetch_record_name_from
+        return nil if fetch_from.nil?
+
+        record.send(fetch_from)
+      end
+
+      # Returns the encryption key for the record.
+      def encryption_key_for_record(record)
+        ::LoggableActivity::EncryptionKey.for_record(record)
+      end
+
+      # Build a encrypted payload for a record
+      def build_encrypted_payload(record, options = {})
+        encryption_key = encryption_key_for_record(record)
+        return if encryption_key.deleted?
+
+        secret_key = encryption_key.secret_key
+        encrypted_attrs = encrypt_attributes(record, secret_key)
+
+        build_payload(
+          record,
+          encryption_key,
+          encrypted_attrs,
+          options
+        )
+        { encryption_key:, encrypted_attrs: }
+      end
+
+      # Builds the payload for a record
+      def build_payload(record, encryption_key, encrypted_attrs, options = {})
+        return if encryption_key.deleted?
+
+        related_to_activity_as = options[:related_to_activity_as]
+        current_payload = options[:current_payload]
+        data_owner = options[:data_owner]
+
+        secret_key = encryption_key.secret_key
+        encrypted_record_name = encrypt_record_name_for_record(record, secret_key)
+        payload = ::LoggableActivity::Payload.new(
+          encryption_key:,
+          record:,
+          encrypted_record_name:,
+          encrypted_attrs:,
+          related_to_activity_as:,
+          route: record.class.route,
+          current_payload:,
+          data_owner:
+        )
+        unless payload.valid?
+          error_message = "Payload validation failed: #{payload.errors.full_messages.join(', ')}"
+          raise LoggableActivity::Error, error_message
+        end
+
+        @payloads << payload
+      end
+
+      # Encrypts the attributes for the record.
+      def encrypt_attributes(record, secret_key)
+        encrypt_attrs(record.attributes, record.class.loggable_attrs, secret_key)
+      end
+
+      # Encrypt one attributes for only loggable_attrs, configured
+      def encrypt_attrs(attrs, loggable_attrs, secret_key)
+        attrs.slice(*loggable_attrs).transform_values do |value|
+          ::LoggableActivity::Encryption.encrypt(value, secret_key)
+        end
+      end
+
+      # Encrypt a single attribute.
+      def encrypt_attr(value, secret_key)
+        ::LoggableActivity::Encryption.encrypt(value, secret_key)
+      end
+    end
+  end
+end

data/lib/loggable_activity/services/destroy_payloads_builder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module LoggableActivity
+  # Namespace for services
+  module Services
+    # This class is responsible for building destroy payloads used in loggable activities.
+    class DestroyPayloadsBuilder < BasePayloadsBuilder
+      # Build payloads for a ::LoggableActivity::Activity.
+      #
+      #  Example:
+      #    build_payloads
+      #
+      #  Returns:
+      #   #<::LoggableActivity::Payload:0x0000000109658718> {
+      #                    :id => 129,
+      #           :record_type => "Demo::Club",
+      #             :record_id => 4,
+      #       :encrypted_attrs => {
+      #           "name" => "z/jigjcm3Fb89L7QT8XiNhvVgjtRXKkmg/xohR6wIc0=\n"
+      #       },
+      #
+      def build
+        build_primary_destroy_payload
+        build_relations_destroy_payloads
+        @payloads
+      end
+
+      private
+
+      def build_primary_destroy_payload
+        encryption_key = encryption_key_for_record(@record)
+        secret_key = encryption_key.secret_key
+        encrypt_attrs(@record.attributes, @record.class.loggable_attrs, secret_key)
+        encrypt_record_name_for_record(@record, secret_key)
+
+        build_encrypted_destroy_payload(@record, 'primary_destroy_payload')
+
+        # @payloads << ::LoggableActivity::Payload.new(
+        #   encryption_key:,
+        #   record_id: nil,
+        #   record_type: @record.class.name,
+        #   encrypted_record_name:,
+        #   encrypted_attrs:,
+        #   related_to_activity_as: 'primary_destroy_payload',
+        #   data_owner: true,
+        #   route: @record.class.route
+        # )
+        # encryption_key
+      end
+
+      def build_relations_destroy_payloads
+        @relations.each do |relation_config|
+          build_relation_destroy_payload(relation_config)
+        end
+      end
+
+      def build_relation_destroy_payload(relation_config)
+        relation_config.each_key do |key|
+          case key
+          when 'belongs_to'
+            # build_belongs_to_destroy_payload(relation_config)
+          when 'has_one'
+            build_has_one_destroy_payload(relation_config)
+          when 'has_many'
+            build_has_many_destroy_payloads(relation_config) # if relation_config['data_owner']
+          end
+        end
+      end
+
+      def build_belongs_to_destroy_payload(relation_config)
+        relation = (relation_config['belongs_to']).to_s
+        record = @record.send(relation)
+        return if record.nil? ||
+
+                  build_encrypted_destroy_payload(record, 'belongs_to_destroy_payload')
+
+        encryption_key_for_record(record).mark_as_deleted!
+        # payload[:encryption_key].mark_as_deleted!
+      end
+
+      def build_has_one_destroy_payload(relation_config)
+        relation = (relation_config['has_one']).to_s
+        record = @record.send(relation)
+        return nil if record.nil?
+
+        record.disable_hooks = true
+
+        build_encrypted_destroy_payload(record, 'has_one_destroy_payload')
+      end
+
+      def build_has_many_destroy_payloads(relation_config)
+        relation = (relation_config['has_many']).to_s
+        records = @record.send(relation)
+        records.each do |record|
+          record.disable_hooks = true
+          build_encrypted_destroy_payload(record, 'has_many_destroy_payload')
+          # build_encrypted_payload(
+          #   record,
+          #   'has_many_destroy_payload',
+          #   relation_config['data_owner'],
+          #   true
+          # )
+        end
+      end
+
+      def build_encrypted_destroy_payload(record, related_to_activity_as)
+        encryption_key = encryption_key_for_record(record)
+        secret_key = encryption_key.secret_key
+        encrypted_attrs = encrypt_attrs(record.attributes, record.class.loggable_attrs, secret_key)
+        encrypted_record_name = encrypt_record_name_for_record(record, secret_key)
+
+        @payloads << ::LoggableActivity::Payload.new(
+          encryption_key:,
+          record_id: nil,
+          record_type: @record.class.name,
+          encrypted_record_name:,
+          encrypted_attrs:,
+          related_to_activity_as:,
+          data_owner: true,
+          route: '',
+          current_payload: true
+        )
+        encryption_key
+      end
+    end
+  end
+end