loggable_activity 0.1.36

data/lib/loggable_activity/activity.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# This is the activity log. It contains an agregation of payloads.
+# It reprecent one activity for the log
+
+module LoggableActivity
+  class Activity < ActiveRecord::Base
+    self.table_name = 'loggable_activities'
+    has_many :payloads, class_name: 'LoggableActivity::Payload', dependent: :destroy
+    accepts_nested_attributes_for :payloads
+
+    validates :actor, presence: true
+    validates :action, presence: true
+    # validates :encrypted_record_display_name, presence: true
+    # validates :encrypted_actor_display_name, presence: true
+
+    validate :must_have_at_least_one_payload
+
+    belongs_to :record, polymorphic: true, optional: true
+    belongs_to :actor, polymorphic: true, optional: true
+
+    def attrs
+      # @attrs ||= payloads_attrs
+      payloads_attrs
+    end
+
+    def update_activity_attrs
+      {
+        update_attrs:,
+        updated_relations_attrs:
+      }
+    end
+
+    def primary_payload_attrs
+      primary_payload ? primary_payload.attrs : {}
+    end
+
+    def primary_payload
+      # @primary_payload ||= ordered_payloads.find { |p| p.payload_type == 'primary_payload' }
+      ordered_payloads.find { |p| p.payload_type == 'primary_payload' }
+    end
+
+    def ordered_payloads
+      # @ordered_payloads ||= payloads.order(:payload_type)
+      payloads.order(:payload_type)
+    end
+
+    def relations_attrs
+      attrs.filter { |p| p[:payload_type] == 'current_association' }
+    end
+
+    def updated_relations_attrs
+      grouped_associations = attrs.group_by { |p| p[:record_class] }
+
+      grouped_associations.map do |record_class, 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_class:, previous_attrs:, current_attrs: }
+      end.compact
+    end
+
+    def payloads_attrs
+      ordered_payloads.map do |payload|
+        {
+          record_class: payload.record_type,
+          payload_type: payload.payload_type,
+          attrs: payload.attrs
+        }
+      end
+    end
+
+    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
+
+    def previous_associations_attrs
+      attrs.select { |p| p[:payload_type] == 'previous_association' }
+    end
+
+    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)
+    end
+
+    def actor_display_name
+      return I18n.t('loggable.activity.deleted') if encrypted_actor_display_name.nil?
+
+      LoggableActivity::Encryption.decrypt(encrypted_actor_display_name, actor_key)
+    end
+
+    def actor_key
+      LoggableActivity::EncryptionKey.for_record(actor)&.key
+    end
+
+    def record_key
+      LoggableActivity::EncryptionKey.for_record(record)&.key
+    end
+
+    def self.activities_for_actor(actor)
+      LoggableActivity::Activity.where(actor:).order(created_at: :desc)
+    end
+
+    def self.latest(limit = 20, params = { offset: 0 })
+      offset = params[:offset] || 0
+      LoggableActivity::Activity
+        .all
+        .order(created_at: :desc)
+        .includes(:payloads)
+        .offset(offset)
+        .limit(limit)
+    end
+
+    def must_have_at_least_one_payload
+      errors.add(:payloads, 'must have at least one payload') if payloads.empty?
+    end
+  end
+end

data/lib/loggable_activity/configuration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module LoggableActivity
+  class Configuration
+    def self.load_config_file(config_file_path)
+      @config_data = YAML.load_file(config_file_path)
+    end
+
+    def self.for_class(class_name)
+      @config_data[class_name]
+    end
+  end
+end

data/lib/loggable_activity/encryption.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# This is a module for encryption and decryption of attributes
+require 'openssl'
+require 'base64'
+
+module LoggableActivity
+  class EncryptionError < StandardError
+  end
+
+  module Encryption
+    def self.encrypt(data, encryption_key)
+      return nil if data.nil?
+      return nil if encryption_key.nil?
+      raise EncryptionError, 'Encryption failed: Invalid encryption key length' unless encryption_key.bytesize == 32
+
+      cipher = OpenSSL::Cipher.new('AES-128-CBC').encrypt
+      cipher.key = Digest::SHA1.hexdigest(encryption_key)[0..15]
+      encrypted = cipher.update(data.to_s) + cipher.final
+      Base64.encode64(encrypted)
+    rescue OpenSSL::Cipher::CipherError => e
+      raise EncryptionError, "Encryption failed: #{e.message} ***"
+    end
+
+    def self.decrypt(data, encryption_key)
+      return I18n.t('loggable.activity.deleted') if blank?(data) || blank?(encryption_key)
+
+      cipher = OpenSSL::Cipher.new('AES-128-CBC').decrypt
+      cipher.key = Digest::SHA1.hexdigest(encryption_key)[0..15]
+      decrypted_data = Base64.decode64(data)
+      decrypted_output = cipher.update(decrypted_data) + cipher.final
+      raise 'Decryption failed: Invalid UTF-8 output' unless decrypted_output.valid_encoding?
+
+      decrypted_output.force_encoding('UTF-8')
+    rescue OpenSSL::Cipher::CipherError => e
+      raise EncryptionError, e.message
+    end
+
+    def self.blank?(value)
+      value.respond_to?(:empty?) ? value.empty? : !value
+    end
+  end
+end

data/lib/loggable_activity/encryption_key.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# This the key used to unlock the data for one payload.
+# When deleted only the encryption_key field is deleted.
+
+module LoggableActivity
+  class EncryptionKey < ActiveRecord::Base
+    self.table_name = 'loggable_encryption_keys'
+    require 'securerandom'
+    belongs_to :record, polymorphic: true, optional: true
+    belongs_to :parrent_key, class_name: 'LoggableActivity::EncryptionKey', optional: true,
+                             foreign_key: 'parrent_key_id'
+
+    def mark_as_deleted
+      update(key: nil)
+      parrent_key.mark_as_deleted if parrent_key.present?
+    end
+
+    def self.for_record_by_type_and_id(record_type, record_id, parrent_key = nil)
+      enctyption_key = find_by(record_type:, record_id:)
+
+      return enctyption_key if enctyption_key
+
+      create_encryption_key(record_type, record_id, parrent_key)
+    end
+
+    def self.for_record(record, parrent_key = nil)
+      encryption_key = find_by(record:)
+      return encryption_key if encryption_key
+
+      create_encryption_key(record.class.name, record.id, parrent_key)
+    end
+
+    def self.create_encryption_key(record_type, record_id, parrent_key = nil)
+      if parrent_key
+        create(record_type:, record_id:, key: random_key, parrent_key_id: parrent_key.id)
+      else
+        create(record_type:, record_id:, key: random_key)
+      end
+    end
+
+    def self.random_key
+      SecureRandom.hex(16)
+    end
+  end
+end

data/lib/loggable_activity/hooks.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# 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
+  module Hooks
+    extend ActiveSupport::Concern
+    include LoggableActivity::PayloadsBuilder
+    include LoggableActivity::UpdatePayloadsBuilder
+
+    included do
+      config = LoggableActivity::Configuration.for_class(name)
+      if config.nil?
+        raise "Loggable::Configuration not found for #{name}, Please add it to 'config/loggable_activity.yaml'"
+      end
+
+      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)
+
+      after_create :log_create_activity
+      after_update :log_update_activity
+      before_destroy :log_destroy_activity
+
+      # has_one: encryption_key, as: :encryption_key, class_name: 'LoggableActivity::EncryptionKey'
+    end
+
+    # This is the main method for logging activities.
+    # It is never called from the directly from the controller.
+    def log(action, actor: nil, params: {})
+      @action = action
+      @actor = actor || Thread.current[:current_user]
+      # LoggableActivity::EncryptionKey.for_record(self)
+
+      return if @actor.nil?
+
+      @record = self
+      @params = params
+      @payloads = []
+
+      case action
+      when :create, :show
+        log_activity
+      when :destroy
+        log_destroy
+      when :update
+        log_update
+      else
+        log_custom_activity(action)
+      end
+    end
+
+    private
+
+    def log_activity
+      create_activity(build_payloads)
+    end
+
+    def log_update
+      create_activity(build_update_payloads)
+    end
+
+    def log_destroy
+      create_activity(build_destroy_payload)
+    end
+
+    def create_activity(payloads)
+      return if nothing_to_log?(payloads)
+
+      LoggableActivity::Activity.create!(
+        encrypted_actor_display_name: encrypted_actor_name,
+        encrypted_record_display_name: encrypted_record_name,
+        action: action_key,
+        actor: @actor,
+        record: @record,
+        payloads:
+      )
+    end
+
+    def nothing_to_log?(payloads)
+      payloads.empty?
+    end
+
+    def log_custom_activity(activity); end
+
+    def log_update_activity
+      log(:update) if self.class.auto_log.include?('update')
+    end
+
+    def log_create_activity
+      log(:create) if self.class.auto_log.include?('create')
+    end
+
+    def log_destroy_activity
+      LoggableActivity::EncryptionKey.for_record(self)&.mark_as_deleted
+      log(:destroy) if self.class.auto_log.include?('destroy')
+    end
+
+    def encrypted_actor_name
+      actor_display_name = @actor.send(actor_display_name_field)
+      LoggableActivity::Encryption.encrypt(actor_display_name, actor_encryption_key)
+    end
+
+    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)
+    end
+
+    def action_key
+      @action_key ||= self.class.base_action + ".#{@action}"
+    end
+
+    def primary_encryption_key
+      @primary_encryption_key ||=
+        LoggableActivity::EncryptionKey.for_record(self)&.key
+    end
+
+    def primary_encryption_key_deleted?
+      primary_encryption_key.nil?
+    end
+
+    def actor_encryption_key
+      LoggableActivity::EncryptionKey.for_record(@actor)&.key
+    end
+
+    def actor_display_name_field
+      Rails.application.config.loggable_activity.actor_display_name || "id: #{@actor.id}, class: #{@actor.class.name}"
+    end
+
+    def current_user_model?
+      Rails.application.config.loggable_activity.current_user_model_name == self.class.name
+    end
+
+    class_methods do
+      attr_accessor :loggable_attrs, :relations, :auto_log, :actor_display_name, :record_display_name
+
+      def base_action
+        name.downcase.gsub('::', '/')
+      end
+    end
+  end
+end

data/lib/loggable_activity/payload.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# This is the payload of the log. It contains the encrypted data of one record in the DB.
+# When the record is deleted, the encryption_key for the payload is deleted.
+# Payloads comes in different flavors.
+# The primary_payload is the payload that contains the parrent record.
+# When fecthing the attrs, they are packed differently depending on the payload_type.
+
+module LoggableActivity
+  class Payload < ActiveRecord::Base
+    self.table_name = 'loggable_payloads'
+    belongs_to :record, polymorphic: true, optional: true
+
+    belongs_to :activity
+    belongs_to :record, polymorphic: true, optional: true
+    validates :encrypted_attrs, presence: true
+    enum payload_type: {
+      primary_payload: 0,
+      update_payload: 1,
+      current_association: 2,
+      previous_association: 3
+    }
+
+    def attrs
+      return deleted_attrs if record.nil?
+
+      case payload_type
+      when 'current_association', 'primary_payload', 'previous_association'
+        decrypted_attrs
+      when 'update_payload'
+        decrypted_update_attrs
+        # when 'destroy_payload'
+        #   destroy_payload_attrs
+      end
+    end
+
+    def payload_encryption_key
+      @payload_encryption_key ||= LoggableActivity::EncryptionKey.for_record(record)&.key
+    end
+
+    private
+
+    def deleted_attrs
+      encrypted_attrs.transform_values! { I18n.t('loggable.activity.deleted') }
+    end
+
+    def decrypted_update_attrs
+      encrypted_attrs['changes'].map do |change|
+        decrypted_from_to_attr(change)
+      end
+    end
+
+    def decrypted_from_to_attr(change)
+      change.to_h do |key, value|
+        from = decrypt_attr(value['from'])
+        to = decrypt_attr(value['to'])
+        [key, { from:, to: }]
+      end
+    end
+
+    def decrypted_attrs
+      encrypted_attrs.each do |key, value|
+        encrypted_attrs[key] = decrypt_attr(value)
+      end
+    end
+
+    def decrypt_attr(value)
+      LoggableActivity::Encryption.decrypt(value, payload_encryption_key)
+    end
+  end
+end

data/lib/loggable_activity/payloads_builder.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# This is a factory for building payloads.
+
+module LoggableActivity
+  module PayloadsBuilder
+    def build_payloads
+      build_primary_payload
+      self.class.relations.each do |relation_config|
+        build_relation_payload(relation_config)
+      end
+      @payloads
+    end
+
+    def build_primary_payload
+      encrypted_attrs = encrypt_attrs(attributes, self.class.loggable_attrs, primary_encryption_key)
+      @payloads << LoggableActivity::Payload.new(
+        record: @record,
+        payload_type: 'primary_payload',
+        encrypted_attrs:,
+        data_owner: true
+      )
+    end
+
+    def build_destroy_payload
+      encrypted_attrs = encrypt_attrs(attributes, self.class.loggable_attrs, primary_encryption_key)
+      encrypted_attrs.transform_values! { '*** DELETED ***' }
+      @payloads << LoggableActivity::Payload.new(
+        record: @record,
+        payload_type: 'primary_payload',
+        encrypted_attrs:,
+        data_owner: true
+      )
+    end
+
+    def build_relation_payload(relation_config)
+      relation_config.each_key do |key|
+        case key
+        when 'belongs_to'
+          build_payload(relation_config, 'belongs_to')
+        when 'has_one'
+          build_payload(relation_config, 'has_one')
+        end
+      end
+    end
+
+    def build_payload(relation_config, ralation_type)
+      associated_record = send(relation_config[ralation_type])
+      return nil if associated_record.nil?
+
+      associated_loggable_attrs = relation_config['loggable_attrs']
+
+      encryption_key = associated_record_encryption_key(associated_record, relation_config['data_owner'])
+
+      encrypted_attrs =
+        encrypt_attrs(
+          associated_record.attributes,
+          associated_loggable_attrs,
+          encryption_key.key
+        )
+
+      @payloads << LoggableActivity::Payload.new(
+        record: associated_record,
+        encrypted_attrs:,
+        payload_type: 'current_association',
+        data_owner: relation_config['data_owner']
+      )
+    end
+
+    def associated_record_encryption_key(associated_record, data_owner)
+      if data_owner
+        LoggableActivity::EncryptionKey.for_record(associated_record, LoggableActivity::EncryptionKey.for_record(self))
+      else
+        LoggableActivity::EncryptionKey.for_record(associated_record)
+      end
+    end
+
+    def encrypt_attrs(attrs, loggable_attrs, encryption_key)
+      attrs = attrs.slice(*loggable_attrs)
+      encrypt_attr(attrs, encryption_key)
+    end
+
+    def encrypt_attr(attrs, encryption_key)
+      attrs.each do |key, value|
+        attrs[key] = LoggableActivity::Encryption.encrypt(value, encryption_key)
+      end
+    end
+  end
+end

data/lib/loggable_activity/update_payloads_builder.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# This is a factory for building update payloads
+
+module LoggableActivity
+  module UpdatePayloadsBuilder
+    def build_update_payloads
+      @update_payloads = []
+
+      previous_values, current_values = primary_update_attrs
+      build_primary_update_payload(previous_values, current_values)
+
+      self.class.relations.each do |relation_config|
+        build_update_relation_payloads(relation_config)
+      end
+      @update_payloads
+    end
+
+    def primary_update_attrs
+      previous_values = saved_changes.transform_values(&:first)
+      current_values = saved_changes.transform_values(&:last)
+
+      [previous_values, current_values]
+    end
+
+    def build_primary_update_payload(previous_values, current_values)
+      return if previous_values == current_values
+
+      encrypted_update_attrs = encrypted_update_attrs(previous_values, current_values)
+      @update_payloads << LoggableActivity::Payload.new(
+        record: @record,
+        payload_type: 'update_payload',
+        encrypted_attrs: encrypted_update_attrs
+      )
+    end
+
+    def encrypted_update_attrs(previous_values, current_values)
+      changes = []
+      changed_attrs = previous_values.slice(*self.class.loggable_attrs)
+      changed_attrs.each do |key, from_value|
+        from = LoggableActivity::Encryption.encrypt(from_value, primary_encryption_key)
+        to_value = current_values[key]
+        to = LoggableActivity::Encryption.encrypt(to_value, primary_encryption_key)
+        changes << { key => { from:, to: } }
+      end
+      { changes: }
+    end
+
+    def build_update_relation_payloads(relation_config)
+      relation_config.each_key do |key|
+        case key
+        when 'belongs_to'
+          build_relation_update_for_belongs_to(relation_config)
+        end
+      end
+    end
+
+    def build_relation_update_for_belongs_to(relation_config)
+      relation_id = "#{relation_config['belongs_to']}_id"
+      model_class_name = relation_config['model']
+      model_class = model_class_name.constantize
+
+      return unless saved_changes.include?(relation_id)
+
+      relation_id_changes = saved_changes[relation_id]
+      previous_relation_id, current_relation_id = relation_id_changes
+
+      [previous_relation_id, current_relation_id].each_with_index do |id, index|
+        relation_record = id ? model_class.find_by(id:) : nil
+        next unless relation_record
+
+        payload_type = index.zero? ? 'previous_association' : 'current_association'
+        build_relation_update_payload(
+          relation_record.attributes,
+          relation_config['loggable_attrs'],
+          relation_record,
+          payload_type
+        )
+      end
+    end
+
+    def build_relation_update_payload(_attrs, loggable_attrs, record, payload_type)
+      encryption_key = LoggableActivity::EncryptionKey.for_record(record)&.key
+      encrypted_attrs = relation_encrypted_attrs(record.attributes, loggable_attrs, encryption_key)
+
+      ap "building relation update payload for #{record.id} with encryption_key: #{encryption_key}"
+
+      @update_payloads << LoggableActivity::Payload.new(
+        record:,
+        encrypted_attrs:,
+        payload_type:
+      )
+    end
+
+    def relation_encrypted_attrs(attrs, loggable_attrs, encryption_key)
+      encrypt_attrs(attrs, loggable_attrs, encryption_key)
+    end
+  end
+end

data/lib/loggable_activity/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LoggableActivity
+  VERSION = '0.1.36'
+end

data/lib/loggable_activity.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# require 'rails'
+
+require_relative 'loggable_activity/activity'
+require_relative 'loggable_activity/configuration'
+require_relative 'loggable_activity/encryption'
+require_relative 'loggable_activity/encryption_key'
+require_relative 'loggable_activity/hooks'
+require_relative 'loggable_activity/payload'
+require_relative 'loggable_activity/payloads_builder'
+require_relative 'loggable_activity/update_payloads_builder'
+require_relative 'loggable_activity/version'
+
+module LoggableActivity
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/loggable_activity.rbs

@@ -0,0 +1,4 @@
+module LoggableActivity
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end