dcidev_approval 0.0.8 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 113b68a6c6cc3aa09902b2ede950d44deaa4a3f9cfe8a72c4ab4e1a9051e5ca7
-  data.tar.gz: 489f1c91e45864e4d88ab12bd32dd34f9eafc1c1e381d9d8be92884703e7f316
+  metadata.gz: acf499a815402aa955b457d3fa2db0a97a6018135c1c8814ecad4c4894eeaf62
+  data.tar.gz: 12c8dffb9dea52b6d335e0a38194344f780dbf9e7d13259d4c92892d92dbdc60
 SHA512:
-  metadata.gz: 6b59254605c479585ecd5289dfd6e1f41c15aa4cde5888a4c1f834633a1f56e13d04fe1570762507adf249411d11234e0aaf102bd13e150e9f2dfbe98c40aa98
-  data.tar.gz: c1af9bc61fb9ae9fc0ce9da4daef4b1c9dc44975f04a4a68ca07371f4109ea7c3569f508243ed8fd799c0cb0b354aa2b3e106f27083973ff9875b307bb5becd5
+  metadata.gz: 1cd2869a8e8709375a4b82fde759ab37a7e43a41f1ceedbdf1f563e68a6ac58976c950b8b1088ca8bd7c50ee81e42a8d744bd207d5a5819d23d967fa6be8f242
+  data.tar.gz: 844432fe9092b9918d238ce1ff730dd4028993c087665f26c8361518f49d7c5a189362a7a987c2fc3a92fcb81ecd94cadcd651d3311649fa62e4a79357718e80

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,170 +1,150 @@
-module DcidevApproval
-  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 => _
-        end
-      end
-      return present
-    end
-
-    def waiting_approval?
-      %w[pending_update pending_delete].include?(self.change_status) || self.status == "waiting"
-    end
-
-    def pending_insert?
-      self.change_status.nil? && %w[waiting rejected].include?(self.status)
-    end
-
-    def pending_update?
-      self.change_status == "pending_update"
-    end
-
-    def pending_delete?
-      self.change_status == "pending_delete"
-    end
-
-    def approved?
-      self.status == "approved"
-    end
-
-    def rejected?
-        self.status == "rejected"
-    end
-
-    def waiting?
-        self.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
-      {
-        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
-      }
-    end
-
-    def created_by
-      log = self.activity_logs.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)
-      }
-    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
-      {
-        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_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)
-        # 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")
+# frozen_string_literal: true
 
-      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)
+module DcidevApproval
+    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|
+                if eval("self.#{k}") != v
+                    present = true
+                    break
+                end
+            rescue StandardError => _e
+            end
+            present
+        end
+        
+        def waiting_approval?
+            %w[pending_update pending_delete].include?(change_status) || status == 'waiting'
+        end
+        
+        def pending_insert?
+            change_status.nil? && %w[waiting rejected].include?(status)
+        end
+        
+        def pending_update?
+            change_status == 'pending_update'
+        end
+        
+        def 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
+            log = audit_trails.where(activity_type: %w[update delete]).limit(1).try(:first)
+            {
+                modified_by: log.present? ? log.try(:agent).try(:name).to_s + " (#{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 = audit_trails(:asc).where(activity_type: :create).limit(1).try(:first)
+            {
+                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: self.try(:created_at) || log.try(:created_at)
+            }
+        end
+        
+        def last_approved_by
+            last_approve = audit_trails.where(activity_type: :approve).limit(1).try(:first)
+            last_entry = audit_trails.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_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 change_status.nil? && %w[waiting rejected].include?(status) && !update(status: :approved, data_changes: nil, change_status: nil)
+                raise errors.full_messages.join(', ')
+            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)
+            when 'pending_delete'
+                destroy
+            end
+        end
+        
+        def delete_changes
+            raise errors.full_messages.join(', ') unless update(data_changes: nil, change_status: nil, status: status == 'waiting' ? :rejected : :approved)
+        end
+        
+        def edit_data(params, agent, bypass = true)
+            raise 'data still waiting for approval' if waiting_approval?
+            
+            if bypass
+                raise errors.full_messages.join(', ') unless update_by_params(params, false)
+            elsif changes_present?(params)
+                ActiveRecord::Base.transaction do
+                    data = agent.is_admin? || status == 'waiting' ? params : { change_status: :pending_update, data_changes: agent.is_admin? ? nil : params }
+                    raise errors.full_messages.join(', ') unless update_by_params(data, false)
+                end
+            end
+            yield self
+        end
+        
+        def approval(params)
+            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 waiting_approval?
+            
+            if bypass || agent.is_admin?
+                ActiveRecord::Base.transaction do
+                    raise errors.full_messages.join(', ') unless destroy
+                end
+            else
+                raise errors.full_messages.join(', ') unless update(change_status: :pending_delete)
+            end
+            yield true
         end
-      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)
-      # 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?
-      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
-        end
-      end
-      yield true
-    end
-
-    def approval(params)
-      if params.status == "approved"
-        self.approve_changes
-      elsif params.status == "rejected"
-        self.delete_changes
-      end
-      yield true
-    end
-
-    def delete_data(agent, bypass = true)
-      raise "data still waiting for approval" if self.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
-        end
-      else
-        raise self.errors.full_messages.join(", ") unless self.update(change_status: :pending_delete)
-        # ActivityLog.write("Request Delete #{self.class.to_s}", request, agent, menu, self) if params.log
-      end
-      yield true
     end
-  end
-
-  module ClassMethods
-    def create_data(params, agent, bypass = true)
-      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
-          # 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.status = agent.is_admin? ? :approved : :waiting
-        raise d.errors.full_messages.join(", ") unless d.save
-        # ActivityLog.write("Add #{self.to_s}", request, agent, menu, d) if params.log
-      end
-      yield d
+    
+    module ClassMethods
+        def create_data(params, agent, bypass = true)
+            if bypass
+                ActiveRecord::Base.transaction do
+                    data = params.merge!({ status: :approved })
+                    d = new_from_params(data)
+                    raise d.errors.full_messages.join(', ') unless d.save
+                    
+                    yield d
+                end
+            else
+                d = new_from_params(params)
+                d.status = agent.is_admin? ? :approved : :waiting
+                raise d.errors.full_messages.join(', ') unless d.save
+                
+                yield d
+            end
+        end
     end
-  end
 end
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dcidev_approval
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.12
 platform: ruby
 authors:
 - Punto Damar P
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-04 00:00:00.000000000 Z
+date: 2022-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dcidev_active_record