dcidev_approval 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0f4b607b87d0a4885cb7eed7fa8a669e82e9e6b2fb79f9af7fdf79410b1fcff
-  data.tar.gz: 24ce7542734d119282afc7241a14125c64e1f90000474986b79ea5321f308f66
+  metadata.gz: 047563f0a296d733db4828b485a0446cd2757bb3f915809808555d44719a5e44
+  data.tar.gz: 2a3fb2c40952698d8ea669a33f67bb503e5a0dfb44d6c900caef2d4ef27e1231
 SHA512:
-  metadata.gz: 3ea5cf3de84456bb54c7452e61f871829aa6717325815dd6d153e030ee31a5e2c63db09cc93a9f5783b0630057b86af04bd6cf8dfad4e0165fd0a9f875e15bec
-  data.tar.gz: e5bee4b7d43226dad75d04ac0ba0b4fd6380d6b8d3bc1fd3f27ff8c98c4e951af61fab0f5725fabda1200eea61edf88c260b3811535b3f21f8b5a49f69700f19
+  metadata.gz: b9ef11b07ae7f35c5c21c1a1c93da4565077570d5b277786a87b913d690b9b4885703cbed14337e8ecc9c16c5c0e3f822fd6359776cac2db608069dff51619d2
+  data.tar.gz: '099759cd2d503012da3ac66a22a28fee1b67b2d07e67f0c421ae348477fd7db1898a8fed75087d2365f9dff61cc3c189219fc9184105a0fb8e11990d55684856'

data/README.md

@@ -1 +1,93 @@
-dcidev_approval
+# Setup
+##### 1. Add new column named `status` to every model requiring this gem
+`db/migrate/migration_file.rb`
+```ruby
+class AddStatusToProduk < ActiveRecord::Migration[6.0]
+    def change 
+        add_column :produk, :status, :string
+        add_column :produk, :change_status, :string
+    end
+end
+```
+`app/models/model.rb`
+```ruby
+STATUS = %w[waiting approved rejected].freeze
+enum status: STATUS.zip(STATUS).to_h, _prefix: true
+
+CHANGE_STATUS = %w(pending_delete pending_update).freeze
+enum change_status: CHANGE_STATUS.zip(CHANGE_STATUS).to_h, _prefix: true
+```
+
+
+
+##### 2. Format your `Agent` and `Role` with one-many relationship.
+##### 3.  Declare instance method `is_admin?` to `Agent` to find out whether an agent is an admin or not
+
+```ruby
+def is_admin?
+    # add your custom logic here
+    self.approved? && ["admin", "super_admin", "checker"].include?(self.try(:roles).try(:first).try(:code))
+end
+```
+
+##### 4. Include the module to every model requiring approval. Or just put it in `ApplicationRecord`
+`app/models/application_record.rb`
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+    include DcidevApproval
+    self.abstract_class = true
+    # ...
+end
+```
+
+# Features
+* Create: `Model.create_data(declared(params), current_user, bypass)`
+* Update: `model.edit_data(declared(params), current_user, bypass)`
+* Delete: `model.delete_data(declared(params), current_user, bypass)`
+* Approval: `model.approval(declared(params))`
+* Compare current database value and argument to check if there are any update: `model.changes_present?(params)`
+* Check approval status: `model.waiting_approval?`, `model.pending_insert?`, `model.pending_update?`, `model.pending_delete?`
+* Find last lodifier & timestamp: `model.last_modified_by`
+* Find author: `model.created_by`
+* Find approval agent & timestamp: `model.last_approved_by`
+
+Explanation
+* `declared(params)`: is a hash value from Grape Parameters, plain ruby hash can also be used
+* `current_user`: the agent responsible for the changes
+* `bypass`: boolean value to toogle the approval system. If not sent, the default value is `true`
+
+To track changes peformed to a record, call 
+# Callbacks
+To execute code before/after the CRUD, include module `DcidevApproval` in `ApplicationRecord` and peform overide and or overload on it's child model.
+
+`app/models/application_record.rb`
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+    include DcidevApproval
+    self.abstract_class = true
+    # ...
+end
+```
+
+`app/models/child_model.rb`
+```ruby
+class ChildModel < ApplicationRecord
+    # ...
+    def self.create_data(params, agent, request)
+        super(params, agent, false) do |data|
+            # do something after the record is successfully created
+            # in this case, write an activity log
+            # the data variable will return the created record
+            ActivityLog.write("#{agent.is_admin? || params.bypass ? nil : "Request "} Add #{self.class.to_s}", request, agent, menu, data) if params.log
+        end
+    end
+    
+    def edit_data(params, agent, request)
+        super(params, agent, false) do |_|
+            # do something after the record is successfully edited and require approval
+        end
+    end
+    # ...
+end
+
+```

data/lib/dcidev_approval.rb

@@ -1,135 +1,146 @@
+# frozen_string_literal: true
+
 module DcidevApproval
-  def self.included base
+  def self.included(base)
     base.send :include, InstanceMethods
     base.extend ClassMethods
   end
 
   module InstanceMethods
-
     def changes_present?(changes)
       present = false
       changes.each do |k, v|
-        begin
-          if eval("self.#{k}") != v
-            present = true
-            break
-          end
-        rescue => _
+        if eval("self.#{k}") != v
+          present = true
+          break
         end
+      rescue StandardError => _e
       end
-      return present
+      present
     end
 
     def waiting_approval?
-      %w[pending_update pending_delete].include?(self.change_status) || self.status == "waiting"
+      %w[pending_update pending_delete].include?(change_status) || status == 'waiting'
     end
 
     def pending_insert?
-      self.change_status.nil? && %w[waiting rejected].include?(self.status)
+      change_status.nil? && %w[waiting rejected].include?(status)
     end
 
     def pending_update?
-      self.change_status == "pending_update"
+      change_status == 'pending_update'
     end
 
     def pending_delete?
-      self.change_status == "pending_delete"
+      change_status == 'pending_delete'
+    end
+
+    def approved?
+      status == 'approved' || change_status.nil?
+    end
+
+    def rejected?
+      status == 'rejected'
+    end
+
+    def waiting?
+      status == 'waiting'
     end
 
     def last_modified_by
       # p self.audit_trail
-      if self.try(:change_status).present? && self.try(:change_status) == 'pending_delete'
-        log = self.activity_logs.where("activity LIKE '%delete%'").limit(1).order(created_at: :desc).try(:first)
-      else
-        log = self.activity_logs.where("activity LIKE '%edit%'").limit(1).order(created_at: :desc).try(:first)
-      end
+      log = activity_logs.where(activity_type: %w[update delete]).limit(1).order(created_at: :desc).try(:first)
       {
-        modified_by: log.present? ? log.try(:agent).try(:name).to_s + " (#{log.try(:agent).try(:username).to_s} | #{log.try(:agent).try(:roles).try(:first).try(:name)})" : "System",
-        modified_at: log.present? ? log.try(:created_at) || self.try(:updated_at) || self.try(:created_at) : nil
+        modified_by: log.present? ? log.try(:agent).try(:name).to_s + " (#{log.try(:agent).try(:username)} | #{log.try(:agent).try(:roles).try(:first).try(:name)})" : nil,
+        modified_at: log.present? ? log.try(:created_at) || try(:updated_at) || try(:created_at) : nil
       }
     end
 
     def created_by
-      log = self.activity_logs.try(:first)
+      log = activity_logs.order(created_at: :desc).limit(1).try(:first)
       {
-        created_by: log.present? && log.try(:agent).try(:name).present? ? log.try(:agent).try(:name).to_s + " (#{log.try(:agent).try(:username).to_s} | #{log.try(:agent).try(:roles).try(:first).try(:name)})" : "System",
-        created_at: self.try(:created_at) || log.try(:created_at)
+        created_by: log.present? && log.try(:agent).try(:name).present? ? log.try(:agent).try(:name).to_s + " (#{log.try(:agent_role).try(:name)})" : 'System',
+        created_at: try(:created_at) || log.try(:created_at)
       }
     end
 
     def last_approved_by
-      last_approve = self.activity_logs.where("activity LIKE '%approv%'").limit(1).order(created_at: :desc).try(:first)
-      last_entry = self.activity_logs.last
+      last_approve = activity_logs.where(activity_type: 'approve').limit(1).order(created_at: :desc).try(:first)
+      last_entry = activity_logs.limit(1).order(created_at: :desc).try(:first)
       {
-        approved_by: last_approve.try(:id) == last_entry.try(:id) ? last_approve.try(:agent).try(:name).to_s + " (#{last_approve.try(:agent).try(:username).to_s} | #{last_approve.try(:agent).try(:roles).try(:first).try(:name)})"  : nil,
+        approved_by: last_approve.try(:id) == last_entry.try(:id) ? last_approve.try(:agent).try(:name).to_s + " (#{last_approve.try(:agent_role).try(:name)})" : nil,
         approved_at: last_approve.try(:id) == last_entry.try(:id) ? last_approve.try(:created_at) : nil
       }
     end
 
     def approve_changes
-
-      if self.change_status.nil? && %w[waiting rejected].include?(self.status)
-        raise self.errors.full_messages.join(", ") unless self.update(status: :approved, data_changes: nil, change_status: nil)
+      if change_status.nil? && %w[waiting rejected].include?(status) && !update(status: :approved, data_changes: nil, change_status: nil)
+        raise errors.full_messages.join(', ')
         # ActivityLog.write("Approve insert to #{self.class.to_s}", request, agent, menu, self) if params.log
         # self.delay(queue: "reorder_#{self.id}", priority: 0).reorder if self.class.column_names.include?("view_order")
 
       end
-      if self.change_status == "pending_update"
-        raise self.errors.full_messages.join(", ") unless self.update_by_params(self.data_changes, false)
-        raise self.errors.full_messages.join(", ") unless self.update(status: :approved, data_changes: nil, change_status: nil)
-        # ActivityLog.write("Approve update to #{self.class.to_s}", request, agent, menu, self) if params.log
-        # self.delay(queue: "reorder_#{self.id}", priority: 0).reorder if self.class.column_names.include?("view_order")
 
-      elsif self.change_status == "pending_delete"
-        raise self.errors.full_messages.join(", ") unless self.update(change_status: nil, data_changes: nil)
-        ActiveRecord::Base.transaction do
-          # ActivityLog.write("Approve delete to #{self.class.to_s}", request, agent, menu, self) if params.log
-          self.try(:destroy)
-        end
+      case change_status
+      when 'pending_update'
+        raise errors.full_messages.join(', ') unless update_by_params(data_changes, false)
+        raise errors.full_messages.join(', ') unless update(status: :approved, data_changes: nil, change_status: nil)
+      # ActivityLog.write("Approve update to #{self.class.to_s}", request, agent, menu, self) if params.log
+      # self.delay(queue: "reorder_#{self.id}", priority: 0).reorder if self.class.column_names.include?("view_order")
+
+      when 'pending_delete'
+        destroy
       end
     end
 
     def delete_changes
       # return unless %w[pending_update pending_delete].include? self.change_status
-      raise self.errors.full_messages.join(", ") unless self.update(data_changes: nil, change_status: nil, status: self.status == "waiting" ? :rejected : :approved)
+      raise errors.full_messages.join(', ') unless update(data_changes: nil, change_status: nil, status: status == 'waiting' ? :rejected : :approved)
       # ActivityLog.write("Reject changes to #{self.class.to_s}", request, agent, menu, self) if params.log
     end
 
     def edit_data(params, agent, bypass = true)
-      raise "data still waiting for approval" if self.waiting_approval?
+      raise 'data still waiting for approval' if waiting_approval?
+
       if bypass
-        raise self.errors.full_messages.join(", ") unless self.update_by_params(params, false)
-        # ActivityLog.write("Edit #{self.class.to_s}", request, agent, menu, self) if params.log
-      else
-        if self.changes_present?(params)
-          ActiveRecord::Base.transaction do
-            data = (agent.is_admin? || self.status == "waiting") ? params : { change_status: :pending_update, data_changes: agent.is_admin? ? nil : params }
-            raise self.errors.full_messages.join(", ") unless self.update_by_params(data, false)
-          end
-          # ActivityLog.write("#{agent.is_admin? ? nil : "Request "}Edit #{self.class.to_s}", request, agent, menu, self) if params.log
+        raise errors.full_messages.join(', ') unless update_by_params(params, false)
+      # ActivityLog.write("Edit #{self.class.to_s}", request, agent, menu, self) if params.log
+      elsif changes_present?(params)
+        ActiveRecord::Base.transaction do
+          data = if agent.is_admin? || status == 'waiting'
+                   params
+                 else
+                   {
+                     change_status: :pending_update, data_changes: agent.is_admin? ? nil : params
+                   }
+                 end
+          raise errors.full_messages.join(', ') unless update_by_params(data, false)
         end
+        # ActivityLog.write("#{agent.is_admin? ? nil : "Request "}Edit #{self.class.to_s}", request, agent, menu, self) if params.log
       end
       yield self
     end
 
     def approval(params)
-      if params.status == "approved"
-        self.approve_changes
-      elsif params.status == "rejected"
-        self.delete_changes
+      case params.status
+      when 'approved'
+        approve_changes
+      when 'rejected'
+        delete_changes
       end
       yield self
     end
 
     def delete_data(agent, bypass = true)
-      raise "data still waiting for approval" if self.waiting_approval?
+      raise 'data still waiting for approval' if waiting_approval?
+
       if bypass || agent.is_admin?
         ActiveRecord::Base.transaction do
           # ActivityLog.write("Delete #{self.class.to_s}", request, agent, menu, self) if params.log
-          raise self.errors.full_messages.join(", ") unless self.destroy
+          raise errors.full_messages.join(', ') unless destroy
         end
       else
-        raise self.errors.full_messages.join(", ") unless self.update(change_status: :pending_delete)
+        raise errors.full_messages.join(', ') unless update(change_status: :pending_delete)
         # ActivityLog.write("Request Delete #{self.class.to_s}", request, agent, menu, self) if params.log
       end
       yield true
@@ -141,18 +152,19 @@ module DcidevApproval
       if bypass
         ActiveRecord::Base.transaction do
           data = params.merge!({ status: :approved })
-          d = self.new_from_params(data)
-          raise d.errors.full_messages.join(", ") unless d.save
+          d = new_from_params(data)
+          raise d.errors.full_messages.join(', ') unless d.save
+
           yield d
           # ActivityLog.write("#{agent.is_admin? ? nil : "Request "} Add #{self.to_s}", request, agent, menu, d) if params.log
         end
       else
-        d = self.new_from_params(params)
+        d = new_from_params(params)
         d.status = agent.is_admin? ? :approved : :waiting
-        raise d.errors.full_messages.join(", ") unless d.save
+        raise d.errors.full_messages.join(', ') unless d.save
+
         yield d
       end
     end
   end
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dcidev_approval
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.11
 platform: ruby
 authors:
 - Punto Damar P
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-03 00:00:00.000000000 Z
+date: 2022-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dcidev_active_record
@@ -33,10 +33,10 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/dcidev_approval.rb
-homepage:
+homepage: 
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -51,8 +51,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key:
+rubygems_version: 3.1.2
+signing_key: 
 specification_version: 4
 summary: Logic for implementing record changes approval
 test_files: []