effective_logging 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df044f4842187ae687d8fce22ece707399782c32
-  data.tar.gz: d08801613da6ca975bd5fc0fb90834059b221bf6
+  metadata.gz: ad0a757a423a0d5b68a2d92bb665772c2e5ca8c0
+  data.tar.gz: 8d779cd00a570d021e4685dd2c3c6ab4235f97bc
 SHA512:
-  metadata.gz: 61c6a3249e84bb44fcd75af0fcd5d884f23482d6c9b63355f500aa5269ffd3343ce50e774878f4c16a5aa44a862e6eabe89759a4531b0dc47a3b041e4ada3a29
-  data.tar.gz: 33b56849e5103f98ca13091eae5fe92c944a20c23c0a3136f188d22b570addc2e68a5cf13c01ccd41158f69e62a5193cbfd6522cf59954589d1eed676a4eb569
+  metadata.gz: 722d36f2d30fe97be38fb6af0f4d0bde3e27595ebbc25cfe17de3c1805127984dec04e5af9692805639d6dc5e64588700c612c2814f0fdd9b88fd1bc752fd0cb
+  data.tar.gz: 27bf043f29c30a5e71b4ae0e458cc8b1526ce3875879709ddd244681ca9150eb835d732b1db7ac8987640274e5f9ffb6f7333754360c368069b864ebbbe51d10

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2014 Code and Effect Inc.
+Copyright 2017 Code and Effect Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -16,6 +16,7 @@ Automatically logs any email sent by the application, any successful user login
 
 Has an effective_datatables driven admin interface to display and search/sort/filter all logs.
 
+Audits changes and performs Trash restore functionality for Active Record objects.
 
 ## Getting Started
 
@@ -208,14 +209,6 @@ class Post < ActiveRecord::Base
 end
 ```
 
-And to your controller:
-
-```ruby
-class ApplicationController < ActionController::Base
-  before_action :set_log_changes_user
-end
-```
-
 Then to see the log for this resource, on any view:
 
 ```erb
@@ -254,6 +247,36 @@ def log_changes_formatted_value(attribute, value)
 end
 ```
 
+### Trash & Restore
+
+This gem provides a fully functional Trash implementation that can be
+used to delete and restore active record objects in any rails application.
+
+Add to your model:
+
+```ruby
+class Post < ActiveRecord::Base
+  acts_as_trashable
+end
+```
+
+The `acts_as_trashable` mixin sets up `before_destroy` hook and copies the now-deleted attributes to an `Effective::Log` object.
+
+Visit `/trash`, or `/admin/trash` to restore them.
+
+The above routes require the following, user specific, permissions:
+
+```ruby
+can :restore, Effective::Log, user_id: user.id
+```
+
+and for admin:
+
+```ruby
+can :restore, Effective::Log
+can :admin, :effective_logging
+```
+
 ### Logging From JavaScript
 
 First, require the javascript in your application.js:

data/app/controllers/admin/logs_controller.rb

@@ -4,7 +4,7 @@ module Admin
 
     layout (EffectiveLogging.layout.kind_of?(Hash) ? EffectiveLogging.layout[:admin_logs] : EffectiveLogging.layout)
 
-    skip_log_page_views :quiet => true
+    skip_log_page_views quiet: true
     helper EffectiveLoggingHelper
 
     def index

data/app/controllers/admin/trash_controller.rb

@@ -0,0 +1,28 @@
+# This copies the permissions of The Logs controller
+
+module Admin
+  class TrashController < ApplicationController
+    respond_to?(:before_action) ? before_action(:authenticate_user!) : before_filter(:authenticate_user!) # Devise
+
+    layout (EffectiveLogging.layout.kind_of?(Hash) ? EffectiveLogging.layout[:admin_trash] : EffectiveLogging.layout)
+
+    skip_log_page_views quiet: true
+    helper EffectiveLoggingHelper
+
+    def index
+      @datatable = Effective::Datatables::Trash.new()
+      @page_title = 'Trash'
+
+      EffectiveLogging.authorized?(self, :restore, Effective::Log)
+      EffectiveLogging.authorized?(self, :admin, :effective_logging)
+    end
+
+    def show
+      @trash = Effective::Log.trash.find(params[:id])
+      @page_title = "Trash item - #{@trash.to_s}"
+
+      EffectiveLogging.authorized?(self, :restore, @trash)
+      EffectiveLogging.authorized?(self, :admin, :effective_logging)
+    end
+  end
+end

data/app/controllers/effective/trash_controller.rb

@@ -0,0 +1,44 @@
+module Effective
+  class TrashController < ApplicationController
+    if respond_to?(:before_action) # Devise
+      before_action :authenticate_user!
+    else
+      before_filter :authenticate_user!
+    end
+
+    # This is the User index event
+    def index
+      @datatable = Effective::Datatables::Trash.new(user_id: current_user.id)
+      @page_title = 'Trash'
+
+      EffectiveLogging.authorized?(self, :restore, Effective::Log.new(user_id: current_user.id))
+    end
+
+    # This is the User show event
+    def show
+      @trash = Effective::Log.trash.find(params[:id])
+      @page_title = "Trash item - #{@trash.to_s}"
+
+      EffectiveLogging.authorized?(self, :restore, @trash)
+    end
+
+    def restore
+      @trash = Effective::Log.trash.find(params[:id])
+      EffectiveLogging.authorized?(self, :restore, @trash)
+
+      Effective::Log.transaction do
+        begin
+          @trash.restore_trashable!
+          @trash.destroy!
+          flash[:success] = "Successfully restored #{@trash}"
+        rescue => e
+          flash[:danger] = "Unable to restore: #{e.message}"
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      redirect_back(fallback_location: effective_logging.trash_path)
+    end
+
+  end
+end

data/app/helpers/effective_logging_helper.rb

@@ -8,13 +8,15 @@ module EffectiveLoggingHelper
       when 'info'     ; 'info'
       when 'warning'  ; 'warning'
       when 'error'    ; 'danger'
+      when 'trashed'  ; 'default'
       else 'primary'
     end
   end
 
   def render_log(log)
-    render(:partial => 'effective/logs/log', :locals => {:log => log})
+    render(partial: 'effective/logs/log', locals: {:log => log})
   end
+  alias_method :render_trash, :render_log
 
   def parents_of_log(log)
     parents = [log.parent]

data/app/models/concerns/acts_as_trashable.rb

@@ -0,0 +1,40 @@
+module ActsAsTrashable
+  extend ActiveSupport::Concern
+
+  module ActiveRecord
+    def acts_as_trashable(*options)
+      @acts_as_trashable_options = options.try(:first) || {}
+
+      unless @acts_as_trashable_options.kind_of?(Hash)
+        raise ArgumentError.new("invalid arguments passed to (effective_trash) acts_as_trashable. Expecting no options.")
+      end
+
+      include ::ActsAsTrashable
+    end
+  end
+
+  included do
+    has_one :trash, -> { where(status: EffectiveLogging.trashable_status) }, as: :associated, class_name: Effective::Log
+
+    before_destroy do
+      EffectiveLogging::ActiveRecordLogger.new(self, acts_as_trashable_options).trashed!
+      true
+    end
+
+    # Parse Options
+    acts_as_trashable_options = {
+      only: Array(@acts_as_trashable_options[:only]).map { |attribute| attribute.to_s },
+      except: Array(@acts_as_trashable_options[:except]).map { |attribute| attribute.to_s },
+      additionally: Array(@acts_as_trashable_options[:additionally]).map { |attribute| attribute.to_s }
+    }
+
+    self.send(:define_method, :acts_as_trashable_options) { acts_as_trashable_options }
+  end
+
+  module ClassMethods
+  end
+
+  # Regular instance methods
+
+end
+

data/app/models/effective/datatables/trash.rb

@@ -0,0 +1,53 @@
+if defined?(EffectiveDatatables)
+  module Effective
+    module Datatables
+      class Trash < Effective::Datatable
+        include EffectiveLoggingHelper
+
+        datatable do
+          default_order :created_at, :desc
+
+          table_column :created_at, label: 'Destroyed at'
+          table_column :id, visible: false
+
+          unless attributes[:user_id] || attributes[:user] || (attributes[:user] == false)
+            table_column :user, label: 'Destroyed by', visible: false
+          end
+
+          table_column :associated_type, label: 'Type'
+          table_column :associated_id, label: 'Original Id', visible: false
+          table_column :message, label: 'Item'
+
+          table_column :details, visible: true, sortable: false do |trash|
+            tableize_hash(trash.details.except(:trash), th: true, sub_th: false, width: '100%')
+          end
+
+          unless attributes[:actions] == false
+            actions_column partial: 'admin/trash/actions', partial_local: :trash
+          end
+        end
+
+        # A nil attributes[:log_id] means give me all the top level log entries
+        # If we set a log_id then it's for sub logs
+        def collection
+          collection = Effective::Log.trash.includes(:user)
+
+          if attributes[:user_id].present?
+            collection = collection.where(user_id: attributes[:user_id])
+          end
+
+          if attributes[:user].present?
+            collection = collection.where(user: attributes[:user])
+          end
+
+          if attributes[:associated_id] && attributes[:associated_type]
+            collection = collection.where(associated_id: attributes[:associated_id], associated_type: attributes[:associated_type])
+          end
+
+          collection
+        end
+
+      end
+    end
+  end
+end

data/app/models/effective/log.rb

@@ -27,10 +27,23 @@ module Effective
     # end
 
     validates :message, presence: true
-    validates :status, presence: true, inclusion: { in: (EffectiveLogging.statuses + [EffectiveLogging.log_changes_status]) }
+    validates :status, presence: true, inclusion: { in: (EffectiveLogging.statuses + [EffectiveLogging.log_changes_status, EffectiveLogging.trashable_status]) }
 
     default_scope -> { order(updated_at: :desc) }
 
+    scope :logged_changes, -> { where(status: EffectiveLogging.log_changes_status)}
+    scope :changes, -> { where(status: EffectiveLogging.log_changes_status)}
+    scope :trash, -> { where(status: EffectiveLogging.trashable_status)}
+
+    def to_s
+      case status
+      when EffectiveLogging.trashable_status
+        [associated_type, associated_id].join(' ').presence || 'New Trash item'
+      else
+        "Log #{id}"
+      end
+    end
+
     def log(message, status = EffectiveLogging.statuses.first, options = {})
       EffectiveLogger.log(message, status, (options || {}).merge({:parent => self}))
     end
@@ -39,6 +52,13 @@ module Effective
       self[:details] || {}
     end
 
+    # So this is a Trash item
+    # When we delete ourselves, we restore this trash item first
+    def restore_trashable!
+      raise 'no attributes to restore from' unless details.kind_of?(Hash) && details[:attributes].present?
+      associated_type.constantize.new(details[:attributes]).save!
+    end
+
     # def next_log
     #   @next_log ||= Log.unscoped.order(:id).where(:parent_id => self.parent_id).where('id > ?', self.id).first
     # end

data/app/views/admin/trash/_actions.html.haml

@@ -0,0 +1,15 @@
+:ruby
+  show_path =
+    if datatables_active_admin_path?
+      admin_effective_trash_path(trash)
+    elsif datatables_admin_path?
+      effective_logging.admin_trash_path(trash)
+    else
+      effective_logging.trash_path(trash)
+    end
+
+= link_to show_path, title: 'view' do
+  %span.glyphicon.glyphicon-eye-open
+
+= link_to effective_logging.restore_trash_path(trash), title: 'Restore', data: {confirm: 'Restore this item?'} do
+  %span.glyphicon.glyphicon-retweet

data/app/views/admin/trash/index.html.haml

@@ -0,0 +1,3 @@
+%h1.effective-admin-heading= @page_title
+
+= render_datatable(@datatable)

data/app/views/admin/trash/show.html.haml

@@ -0,0 +1,4 @@
+%h1.effective-admin-heading= @page_title
+
+= render_trash(@trash)
+

data/app/views/effective/logs/_log.html.haml

@@ -5,9 +5,14 @@
       = ' > '
     %strong= log.message
     .pull-right
-      = link_to_if(log.prev_log.present?, '< Prev', (request.fullpath.gsub(log.to_param, log.prev_log.try(:to_param).to_s))) { 'Prev' }
-      = ' - '
-      = link_to_if(log.next_log.present?, 'Next >', (request.fullpath.gsub(log.to_param, log.next_log.try(:to_param).to_s))) { 'Next' }
+      - if log.prev_log.present?
+        = link_to '< Prev', request.fullpath.gsub(log.to_param, log.prev_log.try(:to_param).to_s)
+
+      - if log.prev_log && log.next_log
+        = ' - '
+
+      - if log.next_log.present?
+        = link_to 'Next >', request.fullpath.gsub(log.to_param, log.next_log.try(:to_param).to_s)
 
   .panel-body
     .row

data/app/views/effective/trash/index.html.haml

@@ -0,0 +1,6 @@
+%h1.effective-heading= @page_title
+
+- if @datatable.present?
+  = render_datatable(@datatable)
+- else
+  %p You have no previously trashed items

data/app/views/effective/trash/show.html.haml

@@ -0,0 +1,3 @@
+%h1.effective-heading= @page_title
+
+= render_trash(@trash)

data/config/effective_logging.rb

@@ -29,6 +29,13 @@ EffectiveLogging.setup do |config|
   # Admin Screens Layout Settings
   config.layout = 'application'   # All EffectiveLogging controllers will use this layout
 
+  # config.layout = {
+  #   logs: 'application',
+  #   trash: 'application',
+  #   admin_logs: 'admin',
+  #   admin_trash: 'admin'
+  # }
+
   # All statuses defined here, as well as 'info', 'success', and 'error' (hardcoded) will be created as
   # EffectiveLogger.info('my message') macros
   config.additional_statuses = []
@@ -43,4 +50,7 @@ EffectiveLogging.setup do |config|
   # Log all successful user login attempts
   config.user_logins_enabled = true
   config.user_logouts_enabled = false
+
+  # Enable the /trash, /admin/trash and /trash/:id/restore routes. Doesn't affect acts_as_trashable itself.
+  config.trash_enabled = true
 end

data/config/routes.rb

@@ -2,14 +2,24 @@ EffectiveLogging::Engine.routes.draw do
   scope :module => 'effective' do
     # Create is our javascript POST event for EffectiveLogging from JS side
     # The show and index routes are for user specific logs
-    resources :logs, :only => [:create, :show, :index] do
+    resources :logs, only: [:create, :index, :show] do
       member { get :html_part }
     end
+
+    if EffectiveLogging.trash_enabled
+      resources :trash, only: [:index, :show] do
+        member { get :restore }
+      end
+    end
   end
 
   if defined?(EffectiveDatatables)
     namespace :admin do
       resources :logs, :only => [:index, :show]
+
+      if EffectiveLogging.trash_enabled
+        resources :trash, only: [:index, :show]
+      end
     end
   end
 

data/lib/effective_logging/active_record_logger.rb

@@ -25,19 +25,24 @@ module EffectiveLogging
       end
     end
 
+    # before_destroy
+    def trashed!
+      log((resource.to_s rescue ''), status: EffectiveLogging.trashable_status, details: applicable(attributes))
+    end
+
     # before_destroy
     def destroyed!
-      log('Deleted', applicable(attributes))
+      log('Deleted', details: applicable(attributes))
     end
 
     # after_commit
     def created!
-      log('Created', applicable(attributes))
+      log('Created', details: applicable(attributes))
     end
 
     # after_commit
     def updated!
-      log('Updated', applicable(attributes))
+      log('Updated', details: applicable(attributes))
     end
 
     # before_save
@@ -53,9 +58,9 @@ module EffectiveLogging
         end || attribute.titleize
 
         if after.present?
-          log("#{attribute} changed from #{before.presence || BLANK} to #{after.presence || BLANK}", { attribute: attribute, before: before, after: after })
+          log("#{attribute} changed from #{before.presence || BLANK} to #{after.presence || BLANK}", details: { attribute: attribute, before: before, after: after })
         else
-          log("#{attribute} set to #{before || BLANK}", { attribute: attribute, value: before })
+          log("#{attribute} set to #{before || BLANK}", details: { attribute: attribute, value: before })
         end
       end
 
@@ -79,6 +84,7 @@ module EffectiveLogging
 
       # Collect to_s representations for all has_one associations
       (resource.class.try(:reflect_on_all_associations, :has_one) || []).each do |association|
+        next if association.name == :trash && resource.respond_to?(:acts_as_trashable_options) # We skip our own association
         attributes[association.name] = resource.send(association.name).to_s.presence || 'nil'
       end
 
@@ -109,10 +115,10 @@ module EffectiveLogging
 
     private
 
-    def log(message, details = {})
+    def log(message, status: EffectiveLogging.log_changes_status, details: {})
       logger.logged_changes.build(
-        user: EffectiveLogging.log_changes_user,
-        status: EffectiveLogging.log_changes_status,
+        user: EffectiveLogging.current_user,
+        status: status,
         message: "#{"\t" * depth}#{options[:prefix]}#{message}",
         details: details
       ).tap { |log| log.save }

data/lib/effective_logging/engine.rb

@@ -29,6 +29,7 @@ module EffectiveLogging
     initializer 'effective_logging.active_record' do |app|
       ActiveSupport.on_load :active_record do
         ActiveRecord::Base.extend(ActsAsLoggable::ActiveRecord)
+        ActiveRecord::Base.extend(ActsAsTrashable::ActiveRecord)
       end
     end
 
@@ -36,6 +37,7 @@ module EffectiveLogging
     initializer 'effective_logging.log_changes_action_controller' do |app|
       ActiveSupport.on_load :action_controller do
         ActionController::Base.include(EffectiveLogging::LogChangesUser)
+        ActionController::Base.send(:before_action, :set_effective_logging_current_user)
       end
     end
 

data/lib/effective_logging/log_changes_user.rb

@@ -2,16 +2,20 @@ module EffectiveLogging
   module LogChangesUser
 
     # Add me to your ApplicationController
-    # before_action :set_log_changes_user
+    # before_action :set_effective_logging_current_user
 
-    def set_log_changes_user
+    def set_effective_logging_current_user
       if respond_to?(:current_user)
-        EffectiveLogging.log_changes_user = current_user
+        EffectiveLogging.current_user = current_user
       else
-        raise "(effective_logging) set_log_changes_user expects a current_user() method to be available"
+        raise "(effective_logging) set_effective_logging_current_user expects a current_user() method to be available"
       end
     end
 
+    def set_log_changes_user
+      # No longer need to call this
+    end
+
   end
 end
 

data/lib/effective_logging/version.rb

@@ -1,3 +1,3 @@
 module EffectiveLogging
-  VERSION = '1.6.0'.freeze
+  VERSION = '1.7.0'.freeze
 end

data/lib/effective_logging.rb

@@ -15,6 +15,7 @@ module EffectiveLogging
   mattr_accessor :emails_enabled
   mattr_accessor :user_logins_enabled
   mattr_accessor :user_logouts_enabled
+  mattr_accessor :trash_enabled
 
   def self.setup
     yield self
@@ -43,13 +44,17 @@ module EffectiveLogging
     'logged change'.freeze
   end
 
-  # This is set by the "set_log_changes_user" before_filter.
-  def self.log_changes_user=(user)
-    @log_changes_user = user
+  def self.trashable_status
+    'trashed'.freeze
   end
 
-  def self.log_changes_user
-    @log_changes_user
+  # This is set by the "set_effective_logging_current_user" before_filter.
+  def self.current_user=(user)
+    @effective_logging_current_user = user
+  end
+
+  def self.current_user
+    @effective_logging_current_user
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_logging
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-07 00:00:00.000000000 Z
+date: 2017-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -90,15 +90,18 @@ extra_rdoc_files: []
 files:
 - MIT-LICENSE
 - README.md
-- Rakefile
 - app/assets/javascripts/effective_logging.js
 - app/assets/javascripts/effective_logging/effective_logger.js.coffee.erb
 - app/controllers/admin/logs_controller.rb
+- app/controllers/admin/trash_controller.rb
 - app/controllers/effective/logs_controller.rb
+- app/controllers/effective/trash_controller.rb
 - app/helpers/effective_logging_helper.rb
 - app/models/concerns/acts_as_loggable.rb
+- app/models/concerns/acts_as_trashable.rb
 - app/models/effective/access_denied.rb
 - app/models/effective/datatables/logs.rb
+- app/models/effective/datatables/trash.rb
 - app/models/effective/log.rb
 - app/models/effective_logger.rb
 - app/views/active_admin/effective_logging/logs/index.html.haml
@@ -106,9 +109,14 @@ files:
 - app/views/admin/logs/_actions.html.haml
 - app/views/admin/logs/index.html.haml
 - app/views/admin/logs/show.html.haml
+- app/views/admin/trash/_actions.html.haml
+- app/views/admin/trash/index.html.haml
+- app/views/admin/trash/show.html.haml
 - app/views/effective/logs/_log.html.haml
 - app/views/effective/logs/index.html.haml
 - app/views/effective/logs/show.html.haml
+- app/views/effective/trash/index.html.haml
+- app/views/effective/trash/show.html.haml
 - config/effective_logging.rb
 - config/routes.rb
 - db/migrate/01_create_effective_logging.rb.erb

data/Rakefile

@@ -1,20 +0,0 @@
-#!/usr/bin/env rake
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-# Testing tasks
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
-load 'rails/tasks/engine.rake'
-
-Bundler::GemHelper.install_tasks
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-
-desc "Run all specs in spec directory (excluding plugin specs)"
-RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
-
-task :default => :spec