effective_reports 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ff9625e424780a9a874037cce46b15b10cf69eb0d515fb6e426d61076099990c
+  data.tar.gz: a0b984c522429e79878d24064dbd24b3835c7777aa741654ab30a1c1ded90058
+SHA512:
+  metadata.gz: 63940ee370287f6b3b517ce8b7f3a113b1b817615d6443f21fa045165b152b9da19bb925a25abf58f7be63a9172d0770b36d9c0d8e9c3a2f7980d5c614d9ab19
+  data.tar.gz: 7e0494cadaa8e2e98bcf79b0dce96cfd21e518448fdccb8386d335ffac7fe350fe076468a8ede1f61cc1ed85bbafa96d2291d6520aa073e70d191a2da00e2a3a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 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
+"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/README.md

@@ -0,0 +1,110 @@
+# Effective Reports
+
+A dynamic ActiveRecord report builder.
+
+## Getting Started
+
+This requires Rails 6+ and Twitter Bootstrap 4 and just works with Devise.
+
+Please first install the [effective_datatables](https://github.com/code-and-effect/effective_datatables) gem.
+
+Please download and install the [Twitter Bootstrap4](http://getbootstrap.com)
+
+Add to your Gemfile:
+
+```ruby
+gem 'effective_reports'
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+Then run the generator:
+
+```ruby
+rails generate effective_reports:install
+```
+
+The generator will install an initializer which describes all configuration options and creates a database migration.
+
+If you want to tweak the table names, manually adjust both the configuration file and the migration now.
+
+Then migrate the database:
+
+```ruby
+rake db:migrate
+```
+
+Please add the following to your User model:
+
+```
+acts_as_reportable
+
+# { active: nil, inactive: nil, with_first_name: :string, not_in_good_standing: :boolean }
+def reportable_scopes
+  {}
+end
+```
+
+and
+
+```
+Add a link to the admin menu:
+
+```haml
+- if can? :admin, :effective_reports
+  - if can? :index, Effective::Reports
+    = nav_link_to 'Reports', effective_reports.admin_reports_path
+```
+
+## Configuration
+
+## Authorization
+
+All authorization checks are handled via the effective_resources gem found in the `config/initializers/effective_resources.rb` file.
+
+## Effective Roles
+
+This gem works with effective roles for the representative roles.
+
+Configure your `config/initializers/effective_roles.rb` something like this:
+
+```
+```
+
+## Permissions
+
+The permissions you actually want to define are as follows (using CanCan):
+
+```ruby
+if user.persisted?
+end
+
+if user.admin?
+  can :admin, :effective_reports
+end
+```
+
+## License
+
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+## Testing
+
+Run tests by:
+
+```ruby
+rails test
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/effective_reports_manifest.js

@@ -0,0 +1,3 @@
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css
+//= link_tree ../images

data/app/assets/javascripts/effective_reports/base.js

@@ -0,0 +1,15 @@
+// Show and hide the filter values when click filter by column
+// This additional JS is required because the f.show_if doesn't work quite right
+$(document).on('change', "[name^='effective_report[report_columns_attributes]'][name$='[filter]']", function(event) {
+  let $filter = $(event.currentTarget);
+  let $values = $filter.closest('.row').find('.effective-report-filter');
+  let $inputs = $values.find('input,textarea,select,button');
+
+  if($filter.is(':checked')) {
+    $values.show();
+    $inputs.removeAttr('disabled');
+  } else {
+    $values.hide();
+    $inputs.prop('disabled', true);
+  }
+});

data/app/assets/javascripts/effective_reports.js

@@ -0,0 +1 @@
+//= require_tree ./effective_reports

data/app/assets/stylesheets/effective_reports.scss

@@ -0,0 +1 @@
+@import 'effective_reports/base';

data/app/controllers/admin/reports_controller.rb

@@ -0,0 +1,16 @@
+module Admin
+  class ReportsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_reports) }
+
+    include Effective::CrudController
+
+    private
+
+    def permitted_params
+      model = (params.key?(:effective_report) ? :effective_report: :report)
+      params.require(model).permit!
+    end
+
+  end
+end

data/app/datatables/admin/effective_reports_datatable.rb

@@ -0,0 +1,31 @@
+module Admin
+  class EffectiveReportsDatatable < Effective::Datatable
+
+    datatable do
+      order :id
+      col :id, visible: false
+
+      col :created_at, visible: false
+      col :created_by, visible: false
+
+      col :title
+      col :description
+
+      col :reportable_class_name, label: 'Resource', search: EffectiveReports.reportable_classes.map(&:to_s), visible: false
+
+      col :report_columns, label: 'Columns', visible: false
+      col :report_scopes, label: 'Scopes', visible: false
+
+      col(:current_rows_count) do |report|
+        report.collection().count
+      end
+
+      actions_col
+    end
+
+    collection do
+      Effective::Report.deep.all
+    end
+
+  end
+end

data/app/datatables/effective_report_datatable.rb

@@ -0,0 +1,21 @@
+# This renders a datatable based off a report
+
+class EffectiveReportDatatable < Effective::Datatable
+  datatable do
+    skip_save_state!  # Forgets the previous show/hide columns settings
+
+    report.report_columns.each do |column|
+      col(column.name, as: column.as.to_sym)
+    end
+
+  end
+
+  collection do
+    report.collection()
+  end
+
+  def report
+    Effective::Report.find(attributes[:report_id])
+  end
+
+end

data/app/helpers/effective_reports_helper.rb

@@ -0,0 +1,60 @@
+module EffectiveReportsHelper
+
+  def reportable_boolean_collection
+    [['Yes', true], ['No', false]]
+  end
+
+  def reportable_attributes_collection(attributes)
+    macros = [:belongs_to, :belongs_to_polymorphic, :has_many, :has_one]
+
+    {
+      'Attributes' => attributes.select { |_, type| macros.exclude?(type) }.map { |att, _| [att, att] }.sort,
+      'Associations' => attributes.select { |_, type| macros.include?(type) }.map { |att, _| [att, att] }.sort,
+    }
+  end
+
+  def reportable_scopes_collection(scopes)
+    {
+      'Basic' => scopes.select { |_, type| type.blank? }.map { |scope, _| [scope, scope] }.sort,
+      'Advanced' => scopes.select { |_, type| type.present? }.map { |scope, _| [scope, scope] }.sort
+    }
+  end
+
+  def reportable_operations_collection(type)
+    case type
+    when :boolean
+      [
+        ['Equals', :eq],
+        ['Does Not Equal', :not_eq]
+      ]
+    when :string
+      [
+        ['Equals =', :eq],
+        ['Does Not Equal !=', :not_eq],
+        ['Includes', :matches],
+        ['Does Not Include', :does_not_match],
+        ['Starts with', :starts_with],
+        ['Ends with', :ends_with]
+      ]
+    when :integer, :price, :date, :decimal
+      [
+        ['Equals =', :eq],
+        ['Does Not Equal !=', :not_eq],
+        ['Greater than >', :gt],
+        ['Greater than or equal to >=', :gteq],
+        ['Less than <', :lt],
+        ['Less than or equal to <', :lteq],
+      ]
+    when :belongs_to, :belongs_to_polymorphic, :has_many, :has_one
+      [
+        ['ID(s) Equals =', :eq],
+        ['Matches', :matches],
+        ['Does Not Match', :does_not_match],
+        ['SQL', :sql],
+      ]
+    else
+      raise("unexpected reportable operations collection type: #{type || 'nil'}")
+    end
+  end
+
+end

data/app/mailers/effective/reports_mailer.rb

@@ -0,0 +1,38 @@
+module Effective
+  class ReportsMailer < EffectiveReports.parent_mailer_class
+
+    include EffectiveMailer
+    include EffectiveEmailTemplatesMailer if EffectiveReports.use_effective_email_templates
+
+    # def reports_submitted(resource, opts = {})
+    #   @assigns = assigns_for(resource)
+    #   @applicant = resource
+
+    #   subject = subject_for(__method__, "Reports Submitted - #{resource}", resource, opts)
+    #   headers = headers_for(resource, opts)
+
+    #   mail(to: resource.user.email, subject: subject, **headers)
+    # end
+
+    protected
+
+    def assigns_for(resource)
+      if resource.kind_of?(Effective::Reports)
+        return reports_assigns(resource)
+      end
+
+      raise('unexpected resource')
+    end
+
+    def reports_assigns(resource)
+      raise('expected an reports') unless resource.class.respond_to?(:effective_reports_resource?)
+
+      values = {
+        date: reports.created_at.strftime('%F')
+      }.compact
+
+      { reports: values }
+    end
+
+  end
+end

data/app/models/concerns/acts_as_reportable.rb

@@ -0,0 +1,72 @@
+# ActsAsReportable
+#
+# Mark your model with 'acts_as_reportable' to be included in the reports
+
+module ActsAsReportable
+  extend ActiveSupport::Concern
+
+  PRICE_NAME_ATTRIBUTES = ['price', 'subtotal', 'tax', 'total', 'current_revenue', 'current_revenue_subtotal', 'current_revenue_tax', 'deferred_revenue', 'deferred_revenue_subtotal', 'deferred_revenue_tax', 'amount_owing', 'surcharge']
+
+  module Base
+    def acts_as_reportable(options = nil)
+      include ::ActsAsReportable
+    end
+  end
+
+  module ClassMethods
+    def acts_as_reportable?; true; end
+  end
+
+  # Instance Methods
+
+  # { id: :integer, price: :price, created_at: :date }
+  def reportable_attributes
+    all_reportable_attributes || {}
+  end
+
+  # { active: nil, inactive: nil, with_first_name: :string, not_in_good_standing: :boolean }
+  def reportable_scopes
+    {}
+  end
+
+  private
+
+  def all_reportable_attributes
+    columns = (self.class.columns_hash rescue {})
+    names = (self.attributes rescue {})
+    reflections = (self.class.reflect_on_all_associations rescue [])
+
+    atts = names.inject({}) do |h, (name, _)|
+      type = columns[name].type
+
+      type = case type
+        when :datetime then :date
+        when :integer then ((PRICE_NAME_ATTRIBUTES.include?(name) || name.include?('price')) ? :price : :integer)
+        when :text then :string
+        else type
+      end
+
+      h[name.to_sym] = type; h
+    end
+
+    associated = reflections.inject({}) do |h, reflection|
+      case reflection
+      when ActiveRecord::Reflection::BelongsToReflection
+        if reflection.options[:polymorphic]
+          h[reflection.name.to_sym] = :belongs_to_polymorphic
+        else
+          h[reflection.name.to_sym] = :belongs_to
+        end
+      when ActiveRecord::Reflection::HasManyReflection
+        h[reflection.name.to_sym] = :has_many
+      when ActiveRecord::Reflection::HasOneReflection
+        h[reflection.name.to_sym] = :has_one
+      when ActiveRecord::Reflection::ThroughReflection
+        h[reflection.name.to_sym] = :has_many
+      end; h
+    end
+
+    atts.merge(associated)
+  end
+
+end

data/app/models/effective/report.rb

@@ -0,0 +1,94 @@
+module Effective
+  class Report < ActiveRecord::Base
+    self.table_name = EffectiveReports.reports_table_name.to_s
+
+    belongs_to :created_by, polymorphic: true
+
+    has_many :report_columns, -> { ReportColumn.sorted }, inverse_of: :report, dependent: :delete_all
+    accepts_nested_attributes_for :report_columns, allow_destroy: true, reject_if: proc { |atts| atts['name'].blank? }
+
+    has_many :report_scopes, -> { ReportScope.sorted }, inverse_of: :report, dependent: :delete_all
+    accepts_nested_attributes_for :report_scopes, allow_destroy: true, reject_if: proc { |atts| atts['name'].blank? }
+
+    log_changes if respond_to?(:log_changes)
+
+    DATATYPES = [:boolean, :date, :decimal, :integer, :price, :string, :belongs_to, :belongs_to_polymorphic, :has_many, :has_one]
+
+    # Arel::Predications.instance_methods
+    OPERATIONS = [:eq, :not_eq, :matches, :does_not_match, :starts_with, :ends_with, :gt, :gteq, :lt, :lteq, :sql]
+
+    effective_resource do
+      title                     :string
+      reportable_class_name     :string
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:report_columns, :report_scopes) }
+    scope :sorted, -> { order(:title) }
+
+    validates :title, presence: true, uniqueness: true
+    validates :reportable_class_name, presence: true
+
+    def to_s
+      title.presence || 'report'
+    end
+
+    def reportable
+      reportable_class_name.constantize if reportable_class_name.present?
+    end
+
+    def filtered_report_columns
+      report_columns.select(&:filter?)
+    end
+
+    # Used to build the Reports form
+    # { id: :integer, archived: :boolean }
+    def reportable_attributes
+      attributes = Hash((reportable.new.reportable_attributes if reportable))
+
+      attributes.each do |attribute, type|
+        raise("#{reportable}.reportable_attributes #{attribute} => #{type || 'nil'} is invalid. Key must be a symbol") unless attribute.kind_of?(Symbol)
+        raise("#{reportable}.reportable_attributes :#{attribute} => #{type || 'nil'} is invalid. Value must be one of #{DATATYPES.map { |s| ":#{s}"}.join(', ')}") unless DATATYPES.include?(type)
+      end
+
+      attributes
+    end
+
+    # { active: nil, inactive: nil, with_first_name: :string, not_in_good_standing: :boolean }
+    def reportable_scopes
+      scopes = Hash((reportable.new.reportable_scopes if reportable))
+
+      scopes.each do |scope, type|
+        raise("#{reportable}.reportable_scopes #{scope} => #{type || 'nil'} is invalid. Key must be a symbol") unless scope.kind_of?(Symbol)
+        raise("#{reportable}.reportable_scopes :#{scope} => #{type || 'nil'} is invalid. Value must be one of #{DATATYPES.map { |s| ":#{s}"}.join(', ')}") if type.present? && !DATATYPES.include?(type)
+        raise("#{reportable} must respond to reportable scope :#{name}") unless reportable.respond_to?(scope)
+      end
+
+      scopes
+    end
+
+    # The klass to base the collection from
+    def collection
+      collection = reportable.all
+
+      # Apply Scopes
+      report_scopes.each do |scope|
+        collection = (scope.value.nil? ? collection.send(scope.name) : collection.send(scope.name, scope.value))
+      end
+
+      # Apply Includes
+      report_columns.select(&:as_associated?).each do |column|
+        collection = collection.includes(column.name)
+      end
+
+      # Apply Filters
+      report_columns.select(&:filter?).each do |column|
+        collection = Resource.new(collection).search(column.name, column.value, operation: column.operation)
+      end
+
+      collection
+    end
+
+  end
+end

data/app/models/effective/report_column.rb

@@ -0,0 +1,89 @@
+module Effective
+  class ReportColumn < ActiveRecord::Base
+    self.table_name = EffectiveReports.report_columns_table_name.to_s
+
+    belongs_to :report
+
+    log_changes(to: :report) if respond_to?(:log_changes)
+
+    effective_resource do
+      name            :string
+      as              :string
+      position        :integer
+
+      filter          :boolean
+      operation       :string
+
+      value_associated  :text
+      value_boolean     :boolean
+      value_date        :date
+      value_decimal     :decimal
+      value_integer     :integer
+      value_price       :integer
+      value_string      :string
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:report) }
+    scope :sorted, -> { order(:position) }
+
+    before_validation(if: -> { report.present? }) do
+      self.position ||= (report.report_columns.map(&:position).compact.max || -1) + 1
+    end
+
+    before_validation(if: -> { filter? == false }) do
+      assign_attributes(operation: nil, value_associated: nil, value_boolean: nil, value_date: nil, value_decimal: nil, value_integer: nil, value_price: nil, value_string: nil)
+    end
+
+    validates :name, presence: true
+    validates :as, presence: true, inclusion: { in: Report::DATATYPES.map(&:to_s) }
+    validates :position, presence: true
+    validates :operation, presence: true, if: -> { filter? }
+
+    validate(if: -> { filter? }) do
+      if value.blank? && (value != false)
+        self.errors.add(:value_date, "can't be blank")
+        self.errors.add(:value_decimal, "can't be blank")
+        self.errors.add(:value_integer, "can't be blank")
+        self.errors.add(:value_price, "can't be blank")
+        self.errors.add(:value_string, "can't be blank")
+        self.errors.add(:value_associated, "can't be blank")
+        self.errors.add(:value_boolean, "can't be blank")
+      end
+    end
+
+    def to_s
+      [name, operation_label, value].compact.join(' ').presence || 'report column'
+    end
+
+    def as_associated?
+      [:belongs_to, :belongs_to_polymorphic, :has_many, :has_one].include?(as.to_sym)
+    end
+
+    def value
+      value_date || value_decimal || value_integer || value_price || value_string.presence || value_associated.presence || value_boolean
+    end
+
+    def operation_label
+      return unless operation.present?
+
+      case operation.to_sym
+      when :eq then '='
+      when :not_eq then '!='
+      when :matches then '~='
+      when :does_not_match then '!~='
+      when :starts_with then 'starts with'
+      when :ends_with then 'ends with'
+      when :gt then '>'
+      when :gteq then '>='
+      when :lt then '<'
+      when :lteq then '<='
+      when :sql then 'sql'
+      else
+        raise("unexpected operation: #{operation}")
+      end
+    end
+
+  end
+end

data/app/models/effective/report_scope.rb

@@ -0,0 +1,48 @@
+module Effective
+  class ReportScope < ActiveRecord::Base
+    self.table_name = EffectiveReports.report_scopes_table_name.to_s
+
+    belongs_to :report
+
+    log_changes(to: :report) if respond_to?(:log_changes)
+
+    effective_resource do
+      name          :string
+      advanced      :boolean      # The scope is a 0 arity symbol when false, or a 1 arity hash when true
+
+      value_boolean  :boolean
+      value_date     :date
+      value_decimal  :decimal
+      value_integer  :integer
+      value_price    :integer
+      value_string   :string
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:report) }
+    scope :sorted, -> { order(:name) }
+
+    validates :name, presence: true
+
+    validate(if: -> { advanced? }) do
+      if value.blank? && (value != false)
+        self.errors.add(:value_date, "can't be blank")
+        self.errors.add(:value_decimal, "can't be blank")
+        self.errors.add(:value_integer, "can't be blank")
+        self.errors.add(:value_price, "can't be blank")
+        self.errors.add(:value_string, "can't be blank")
+        self.errors.add(:value_boolean, "can't be blank")
+      end
+    end
+
+    def to_s
+      name.presence || 'report scope'
+    end
+
+    def value
+      value_date || value_decimal || value_integer || value_price || value_string.presence || value_boolean
+    end
+
+  end
+end

data/app/views/admin/reports/_form.html.haml

@@ -0,0 +1,8 @@
+= tabs do
+  = tab 'Report' do
+    = render 'admin/reports/form_report', report: report
+
+  - if report.persisted?
+    - if report.respond_to?(:log_changes_datatable)
+      = tab 'Logs' do
+        = render_inline_datatable(report.log_changes_datatable)