resource_quotable 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ebb826f39ace180d8f32e12d12ae50ab90a8b2deefe5f19e156810a5ea99636
+  data.tar.gz: cd2009f815c64a62f51a03a3977a0bfc5d53acbacfe91da5d839b2007e74ee27
+SHA512:
+  metadata.gz: ba541c1da670b1d167bc313399e32c63cfb3858a37072d3ea169a368f1b5e11a813d2c0f5f6e13054afbc6bae72727d5c067fa570c53bafc8108f734fddbbf25
+  data.tar.gz: 6896c4c58ed19679d083243c3cead8419684d73703c50eb52ab634fb78f0a21047e4668a804e3c2be0e0c3a9005169abdda8a7ab3dd945beead747e9a67d042c

data/Changelog.md

@@ -0,0 +1,17 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## [0.2.0] (unreleased)
+### Changed
+- Change Quota system to allow user group configuration.
+
+## [0.1.0] (1/9/22)
+### Changed
+- Quota system by user. (alpha version available in branch `by_user`)
+
+## [0.0.0] (4/8/22)
+### Changed
+- Initial repo creation.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_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

data/Readme.md

@@ -0,0 +1,206 @@
+# ResourceQuotable
+A Rails quota limit gem for resources. UNDER DEVELOPMENT
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'resource_quotable'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Install migrations:
+```bash
+$ rails resource_quotable:install:migrations
+$ rails db:migrate
+```
+
+Mount engine:
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  # ...
+  mount ResourceQuotable::Engine => '/resource_quotable'
+  # ...
+end
+
+```
+
+Configure:
+```ruby
+# config/initializers/resource_quotable.rb
+
+ResourceQuotable.setup do |config|
+
+  ##
+  # Mandatory settings
+  #
+  # Resources to track quota.
+  #   format: Array of strings. Could be anything.
+  #
+  config.resources = %w[ResourceA ResourceB NotModel]
+
+  ##
+  # Optional settings
+
+  # Method to access group form user instance.
+  # default: 'group'
+  config.group_method = 'user_group'
+
+  # Method to access users form group instance.
+  # default: 'users'
+  config.users_method = 'admin_users'
+
+  # main_content ID for rendering.
+  # default: 'resource_quotable_content'
+  config.main_content = 'resource_quotable_content'
+
+  # Base controller.
+  # default: '::ApplicationController'
+  config.base_controller = '::ApplicationController'
+
+  # Actions
+  # Default [:create,:update, :destroy]
+  config.actions = {
+    create: 0,
+    update: 1,
+    destroy: 2,
+    send: 3
+  }.freeze
+
+end
+```
+
+Attach Quotable to model.
+
+```ruby
+class User < ApplicationRecord
+  acts_as_quota_trackable
+  # ....
+  belongs_to :group
+  # ....
+end
+
+class Group < ApplicationRecord
+  acts_as_quotable
+  # ....
+  has_many :users, dependent: :destroy
+  # ....
+end
+```
+
+## Usage
+
+```erb
+<% if allowed_to? :create, 'Post' %>
+  <%= link_to "New", new_post_path %>
+<% end %>
+```
+
+```ruby
+class PostController < ApplicationController
+  # ...
+
+  def new
+    quota_authorize! :create, 'Post'
+    # ...
+  end
+
+  def create
+    quota_increment! :create, 'Post'
+    # ...
+  end
+
+  # ...
+end
+```
+
+## Customizations
+
+Customize views
+
+`rails g resource_quotable:views`
+
+Customize Controllers
+
+```ruby
+class ApplicationController < ActionController::Base
+  # ...
+
+  # Customize how to get the current user model to track
+  # default: current_user
+  def load_quotable_tracker_user
+    # ...
+  end
+
+  # Customize how to retrieve the group model
+  # default: quotum_params[:group_type].constantize.find(quotum_params[:group_id])
+  def load_quotable_group
+    # ...
+  end
+
+  # Customize if the current_user can access to the quota management interface
+  # default: true
+  def allowed_to_manage_quota?
+    # ...
+  end
+
+  # Customize How Quotum model are retrieve/filter. Useful for scopes
+  # default: Quotum
+  def quota_scoped
+    # ...
+  end
+
+  # hook before every action
+  # default: nil
+  def resource_quotable_before
+    # ...
+  end
+
+  # hook after every action
+  # default: nil
+  def resource_quotable_after
+    # ...  
+  end
+
+  # ...
+end
+```
+
+## API
+
+Still Working on this doc....
+
+API is exposed as a services layer.
+
+```ruby
+
+# Check quota for 20 actions on resource for this user
+ResourceQuotable::ActionServices::CheckMultiple.call(user: user, resource: 'ResourceX', action: :create, amount: 20)
+# Increment 20 quota for actions on resource for this user
+ResourceQuotable::ActionServices::IncrementMultiple.call(user: user, resource: 'ResourceX', action: :create, amount: 20)
+
+# Reset. Probably a good idea to have a cron job that call this.
+ResourceQuotable::Reset::Any.call
+ResourceQuotable::Reset::Yearly.call
+ResourceQuotable::Reset::Monthly.call
+ResourceQuotable::Reset::Weekly.call
+ResourceQuotable::Reset::Daily.call
+```
+
+## Contributing
+
+```bash
+$ docker-sync start
+$ docker-compose build
+$ docker-compose run web bundle install
+$ docker-compose run web bundle rails db:setup
+$ docker-compose run web bundle rspec
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/assets/config/resource_quotable_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets/resource_quotable .css

data/app/assets/stylesheets/resource_quotable/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/resource_quotable/application_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  class ApplicationController < ResourceQuotable.base_controller  # :nodoc:
+    protected
+
+    def default_load_quotable_group
+      quotum_params[:group_type].constantize.find(quotum_params[:group_id])
+    end
+
+    def check_authorization
+      raise ResourceQuotable::AuthorizationError unless allowed_to_manage_quota?
+    end
+  end
+end

data/app/controllers/resource_quotable/quota_controller.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  class QuotaController < ResourceQuotable::ApplicationController # :nodoc:
+    layout ResourceQuotable.layout
+
+    before_action :check_authorization
+    before_action :load_quotum, only: %i[show edit update destroy]
+
+    def index
+      resource_quotable_before
+      @page = params[:page] || 1
+      @per_page = params[:per_page] || 5
+
+      @quota = quota_scoped.page(@page).per(@per_page)
+      resource_quotable_after
+    end
+
+    def show
+      resource_quotable_before
+      @quotum_trackers = @quotum.quotum_trackers.page(@page).per(@per_page)
+      resource_quotable_after
+    end
+
+    def new
+      resource_quotable_before
+      @quotum = Quotum.new
+      resource_quotable_after
+    end
+
+    def create
+      resource_quotable_before
+      @quotum = ResourceQuotable::Create.call(
+        group: load_quotable_group || default_load_quotable_group,
+        resource: quotum_params[:resource_class],
+        action: quotum_params[:action].to_sym,
+        period: quotum_params[:period].to_sym,
+        limit: quotum_params[:limit].to_i
+      )
+      resource_quotable_after
+      respond_to do |format|
+        format.html do
+          flash[:notice] = 'Quotum created'
+          redirect_to action: :index
+        end
+        format.js
+      end
+    end
+
+    def edit
+      resource_quotable_before
+      resource_quotable_after
+    end
+
+    def update
+      resource_quotable_before
+      @quotum = ResourceQuotable::Update.call(
+        quotum: @quotum,
+        limit: quotum_edit_params[:limit].to_i
+      )
+      resource_quotable_after
+      respond_to do |format|
+        format.html do
+          flash[:notice] = 'Quotum updated'
+          redirect_to action: :show, id: @quotum.id
+        end
+        format.js
+      end
+    end
+
+    def destroy
+      resource_quotable_before
+      @id = @quotum.id
+      ResourceQuotable::Destroy.call(quotum: @quotum)
+      resource_quotable_after
+      respond_to do |format|
+        format.html do
+          flash[:notice] = 'Quotum deleted'
+          redirect_to action: :index
+        end
+        format.js
+      end
+    end
+
+    protected
+
+    def quotum_params
+      params.require(:quotum).permit(
+        :period,
+        :limit,
+        :resource_class,
+        :action,
+        :group_id,
+        :group_type
+      )
+    end
+
+    def quotum_edit_params
+      params.require(:quotum).permit(:limit)
+    end
+
+    def load_quotum
+      @quotum = quota_scoped.find(params[:id])
+    end
+  end
+end

data/app/controllers/resource_quotable/quotum_trackers_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  class QuotumTrackersController < ResourceQuotable::ApplicationController # :nodoc:
+    layout ResourceQuotable.layout
+
+    before_action :check_authorization
+
+    def reset
+      resource_quotable_before
+
+      @quotum_tracker = ResourceQuotable::QuotumTrackerServices::Reset.call(quotum_tracker: load_quotum_tracker)
+
+      resource_quotable_after
+    end
+
+    protected
+
+    def load_quotum_tracker
+      QuotumTracker.find(params[:id])
+    end
+  end
+end

data/app/models/resource_quotable/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  class ApplicationRecord < ActiveRecord::Base # :nodoc:
+    self.abstract_class = true
+  end
+end

data/app/models/resource_quotable/quotum.rb

@@ -0,0 +1,46 @@
+# == Schema Information
+#
+# Table name: resource_quotable_quota
+#
+#  id             :integer          not null, primary key
+#  action         :integer          default("create"), not null
+#  group_type     :string           not null
+#  limit          :integer          default(1), not null
+#  period         :integer          default("any"), not null
+#  resource_class :string           not null
+#  created_at     :datetime
+#  updated_at     :datetime
+#  group_id       :integer          not null
+#
+# Indexes
+#
+#  index_resource_quotable_quota_on_group_id  (group_id)
+#  resource_quotable_quota_unique_index       (group_id,resource_class,action,period) UNIQUE
+#
+
+# frozen_string_literal: true
+
+module ResourceQuotable
+  class Quotum < ApplicationRecord # :nodoc:
+    belongs_to :group, polymorphic: true, inverse_of: :quota
+    has_many :quotum_trackers, dependent: :destroy
+
+    scope :for_resource_action, ->(resource, action) { where(action: action, resource_class: resource) }
+
+    validates :resource_class, :action, :period, :limit, presence: true
+
+    enum action: ResourceQuotable.actions, _suffix: true
+
+    enum period: {
+      any: 0,
+      daily: 1,
+      weekly: 2,
+      monthly: 3,
+      yearly: 4
+    }, _suffix: true
+
+    def to_s
+      "#{period.to_s.capitalize} #{action} #{resource_class}."
+    end
+  end
+end

data/app/models/resource_quotable/quotum_tracker.rb

@@ -0,0 +1,60 @@
+# == Schema Information
+#
+# Table name: resource_quotable_quotum_trackers
+#
+#  id        :integer          not null, primary key
+#  counter   :integer          default(0), not null
+#  flag      :boolean          default(FALSE), not null
+#  user_type :string           not null
+#  quotum_id :integer          not null
+#  user_id   :integer          not null
+#
+# Indexes
+#
+#  index_resource_quotable_quotum_trackers_on_quotum_id  (quotum_id)
+#  index_resource_quotable_quotum_trackers_on_user_id    (user_id)
+#  resource_quotable_quotum_trackers_unique_index        (user_id,quotum_id) UNIQUE
+#
+
+# frozen_string_literal: true
+
+module ResourceQuotable
+  # Flag is true when the quota has been reached.
+  class QuotumTracker < ApplicationRecord
+    belongs_to :quotum
+    belongs_to :user, polymorphic: true, inverse_of: :quotum_trackers
+
+    validates :counter, presence: true
+
+    scope :with_active_counter, -> { where('counter > 0') }
+    scope :for_user, ->(user) { where(user: user) }
+    scope :under_limit, ->(limit_to_check_against) { where('counter < ?', limit_to_check_against) }
+    scope :over_limit, ->(limit_to_check_against) { where('counter >= ?', limit_to_check_against) }
+    scope :flagged, -> { where(flag: true) }
+    scope :not_flagged, -> { where(flag: false) }
+
+    delegate :action, :resource_class, :limit, :period, to: :quotum
+
+    def increment!
+      raise ResourceQuotable::QuotaLimitError if flag
+
+      new_counter = counter + 1
+      update(counter: new_counter, flag: (new_counter >= limit))
+    end
+
+    def increment_by!(amount)
+      new_counter = counter + amount
+      raise ResourceQuotable::QuotaMultiLimitError if new_counter > limit
+
+      update(counter: new_counter, flag: (new_counter >= limit))
+    end
+
+    def reset!
+      return if counter.zero?
+
+      self.counter = 0
+      self.flag = (counter >= limit)
+      save
+    end
+  end
+end

data/app/services/resource_quotable/action_services/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  module ActionServices
+    # Check Resource#action Quota for a user.
+    # return false if it is ok.
+    # return true if it is blocked
+    class Base < ResourceQuotable::Base
+      attr_accessor :user, :action, :resource
+
+      validates :user, :resource, presence: true
+      validates_inclusion_of :action, in: ResourceQuotable.actions.keys
+
+      protected
+
+      def find_or_create_quotum_tracker(quotum)
+        quotum_tracker = quotum.quotum_trackers.find_by(user: user)
+        quotum_tracker ||= user.quotum_trackers.create!(quotum: quotum, counter: 0, flag: !quotum.limit.positive?)
+        quotum_tracker
+      end
+    end
+  end
+end

data/app/services/resource_quotable/action_services/check.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  module ActionServices
+    # Check Resource#action Quota for a user.
+    # return false if it is ok.
+    # return true if it is blocked
+    class Check < Base
+      def call
+        user.quota_for_resource_action(resource, action).each do |quotum|
+          quotum_tracker = find_or_create_quotum_tracker(quotum)
+
+          return true if quotum_tracker.flag?
+        end
+        false
+      end
+    end
+  end
+end

data/app/services/resource_quotable/action_services/check_multiple.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  module ActionServices
+    # Check Resource#action Quota for a user.
+    # return false if it is ok.
+    # return true if it is blocked
+    class CheckMultiple < Base
+      attr_accessor :amount
+
+      validates :amount, presence: true
+
+      def call
+        user.quota_for_resource_action(resource, action).each do |quotum|
+          quotum_tracker = find_or_create_quotum_tracker(quotum)
+
+          return true if quotum_tracker.counter + amount > quotum.limit
+        end
+        false
+      end
+    end
+  end
+end

data/app/services/resource_quotable/action_services/increment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  module ActionServices
+    # Increment Resource#action Quota counter for a user.
+    class Increment < Base
+      def call
+        ResourceQuotable::Quotum.transaction do
+          user.quota_for_resource_action(resource, action).each do |quotum|
+            quotum_tracker = find_or_create_quotum_tracker(quotum)
+
+            quotum_tracker.increment!
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/resource_quotable/action_services/increment_multiple.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  module ActionServices
+    # Increment Resource#action Quota counter for a user.
+    class IncrementMultiple < Base
+      attr_accessor :amount
+
+      validates :amount, presence: true
+
+      def call
+        ResourceQuotable::Quotum.transaction do
+          user.quota_for_resource_action(resource, action).each do |quotum|
+            quotum_tracker = find_or_create_quotum_tracker(quotum)
+
+            quotum_tracker.increment_by!(amount)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/resource_quotable/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ResourceQuotable
+  class Base # :nodoc:
+    include ActiveModel::Validations
+
+    def initialize(args = {})
+      args.each do |k, v|
+        instance_variable_set("@#{k}", v) unless v.nil?
+      end
+    end
+
+    def self.call(args = {})
+      service = new(args)
+      raise ArgumentError, service.errors.full_messages.join(', ') if service.invalid?
+
+      service.call
+    end
+
+    def call
+      raise ResourceQuotable::AbstractClassError
+    end
+  end
+end