module Mongoid::Report

Constants

AttachProxy
Batches

Split the queries into threads.

Merger

We are using this class to combine results by group by fields.

QueriesBuilder
ReportProxy
Scope
ScopeCollection
VERSION

Public Class Methods

inherited(subclass) click to toggle source
# File lib/mongoid/report.rb, line 31
def self.inherited(subclass)
  subclass.settings = {}
end

Public Instance Methods

aggregate() click to toggle source
# File lib/mongoid/report.rb, line 138
def aggregate
  ScopeCollection.new(self)
end
aggregate_for(report_module, report_name) click to toggle source

Method for preparing of aggregation scope where you can apply query, yield and other grouping methods.

# File lib/mongoid/report.rb, line 134
def aggregate_for(report_module, report_name)
  Scope.new(self, report_module, report_name)
end
batches(report_module, report_name) click to toggle source
# File lib/mongoid/report.rb, line 116
def batches(report_module, report_name)
  report_module_settings[report_module][:reports][report_name][:batches]
end
columns(report_module, report_name) click to toggle source
# File lib/mongoid/report.rb, line 128
def columns(report_module, report_name)
  report_module_settings[report_module][:reports][report_name][:columns]
end
fields(report_module, report_name) click to toggle source
# File lib/mongoid/report.rb, line 124
def fields(report_module, report_name)
  report_module_settings[report_module][:reports][report_name][:fields]
end
groups(report_module, report_name) click to toggle source
# File lib/mongoid/report.rb, line 120
def groups(report_module, report_name)
  report_module_settings[report_module][:reports][report_name][:group_by]
end
initialize()
initialize_report_module() click to toggle source
# File lib/mongoid/report.rb, line 40
def initialize_report_module
  # Lets store settings under created instance.
  @report_module_settings = self.settings.inject({}) do |hash_module, (report_module, module_settings)|
    hash_module.merge!(
      report_module =>
        {
          fields:     module_settings[:fields],
          group_by:   module_settings[:group_by],
          batches:    module_settings[:batches],
          columns:    module_settings[:columns],
          mapping:    module_settings[:mapping],
          queries:    (module_settings[:queries] || []).dup,
          reports:    (module_settings[:reports] || {}).inject({}) do |hash_report, (report_name, report_settings)|
            hash_report.merge!(
              report_name => {
                collection:  report_settings[:collection],
                fields:      report_settings[:fields],
                group_by:    report_settings[:group_by],
                batches:     report_settings[:batches],
                columns:     report_settings[:columns],
                mapping:     report_settings[:mapping],
                queries:     (report_settings[:queries] || []).dup,
              })
          end
        })
  end

  @report_module_settings.each do |report_module, module_configuration|
    # Lets do not run queries builder in case of missing queries or group
    # by parameters
    unless module_configuration[:queries].empty? && module_configuration[:group_by].empty?
      builder = QueriesBuilder.new(module_configuration)

      # Prepare group queries depends on the configuration in the included
      # class.
      queries = builder.do

      # Now we have access to compiled queries to run it in aggregation
      # framework.
      module_configuration[:queries] = module_configuration[:queries] + queries
    end

    # For now we are filtering by $match queries only.
    matches = module_configuration[:queries].select do |query|
      query['$match'].present?
    end

    module_configuration[:reports].each do |report_name, report_configuration|
      # Lets merge report and module settings together.
      report_configuration[:fields]    = report_configuration[:fields] | module_configuration[:fields]
      report_configuration[:group_by]  = report_configuration[:group_by] | module_configuration[:group_by]
      report_configuration[:columns]   = report_configuration[:columns].merge(module_configuration[:columns])
      report_configuration[:mapping]   = report_configuration[:mapping].merge(module_configuration[:mapping])

      builder = QueriesBuilder.new(report_configuration)

      # Prepare group queries depends on the configuration in the included
      # class.
      queries = builder.do

      # Now we have access to compiled queries to run it in aggregation
      # framework.
      report_configuration[:queries] = report_configuration[:queries] + matches + queries
    end
  end
end
Also aliased as: initialize
mapping(report_module, report_name) click to toggle source
# File lib/mongoid/report.rb, line 112
def mapping(report_module, report_name)
  report_module_settings[report_module][:reports][report_name][:mapping]
end
queries(report_module, report_name) click to toggle source
# File lib/mongoid/report.rb, line 108
def queries(report_module, report_name)
  report_module_settings[report_module][:reports][report_name][:queries]
end