double_entry-reporting 0.1.0

data/lib/double_entry/reporting/aggregate_array.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class AggregateArray < Array
+      # An AggregateArray is awesome
+      # It is useful for making reports
+      # It is basically an array of aggregate results,
+      # representing a column of data in a report.
+      #
+      # For example, you could request all sales
+      # broken down by month and it would return an array of values
+      attr_reader :function, :account, :partner_account, :code, :filter, :range_type, :start, :finish, :currency
+
+      def initialize(function:, account:, code:, partner_account: nil, filter: nil, range_type: nil, start: nil, finish: nil)
+        @function        = function.to_s
+        @account         = account
+        @code            = code
+        @partner_account = partner_account
+        @filter          = filter
+        @range_type      = range_type
+        @start           = start
+        @finish          = finish
+        @currency        = DoubleEntry::Account.currency(account)
+
+        retrieve_aggregates
+        fill_in_missing_aggregates
+        populate_self
+      end
+
+    private
+
+      def populate_self
+        all_periods.each do |period|
+          self << @aggregates[period.key]
+        end
+      end
+
+      def fill_in_missing_aggregates
+        # some aggregates may not have been previously calculated, so we can request them now
+        # (this includes aggregates for the still-running period)
+        all_periods.each do |period|
+          unless @aggregates[period.key]
+            @aggregates[period.key] = Aggregate.formatted_amount(function: function, account: account, code: code,
+                                                                 range: period, partner_account: partner_account, filter: filter)
+          end
+        end
+      end
+
+      # get any previously calculated aggregates
+      def retrieve_aggregates
+        fail ArgumentError, "Invalid range type '#{range_type}'" unless %w(year month week day hour).include? range_type
+        scope = LineAggregate.
+                where(:function => function).
+                where(:range_type => 'normal').
+                where(:account => account.try(:to_s)).
+                where(:partner_account => partner_account.try(:to_s)).
+                where(:code => code.try(:to_s)).
+                where(:filter => filter.inspect).
+                where(LineAggregate.arel_table[range_type].not_eq(nil))
+        @aggregates = scope.each_with_object({}) do |result, hash|
+          hash[result.key] = formatted_amount(result.amount)
+        end
+      end
+
+      def all_periods
+        TimeRangeArray.make(range_type, start, finish)
+      end
+
+      def formatted_amount(amount)
+        amount ||= 0
+        if function == 'count'
+          amount
+        else
+          Money.new(amount, currency)
+        end
+      end
+    end
+  end
+end

data/lib/double_entry/reporting/day_range.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class DayRange < TimeRange
+      attr_reader :year, :week, :day
+
+      def initialize(options)
+        super options
+
+        @week = options[:week]
+        @day = options[:day]
+        week_range = WeekRange.new(options)
+
+        @start = week_range.start + (options[:day] - 1).days
+        @finish = @start.end_of_day
+      end
+
+      def self.from_time(time)
+        week_range = WeekRange.from_time(time)
+        DayRange.new(:year => week_range.year, :week => week_range.week, :day => time.wday == 0 ? 7 : time.wday)
+      end
+
+      def previous
+        DayRange.from_time(@start - 1.day)
+      end
+
+      def next
+        DayRange.from_time(@start + 1.day)
+      end
+
+      def ==(other)
+        week == other.week &&
+          year == other.year &&
+          day == other.day
+      end
+
+      def to_s
+        start.strftime('%Y, %a %b %d')
+      end
+    end
+  end
+end

data/lib/double_entry/reporting/hour_range.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class HourRange < TimeRange
+      attr_reader :year, :week, :day, :hour
+
+      def initialize(options)
+        super options
+
+        @week = options[:week]
+        @day = options[:day]
+        @hour = options[:hour]
+
+        day_range = DayRange.new(options)
+
+        @start = day_range.start + options[:hour].hours
+        @finish = @start.end_of_hour
+      end
+
+      def self.from_time(time)
+        day = DayRange.from_time(time)
+        HourRange.new :year => day.year, :week => day.week, :day => day.day, :hour => time.hour
+      end
+
+      def previous
+        HourRange.from_time(@start - 1.hour)
+      end
+
+      def next
+        HourRange.from_time(@start + 1.hour)
+      end
+
+      def ==(other)
+        week == other.week &&
+          year == other.year &&
+          day == other.day &&
+          hour == other.hour
+      end
+
+      def to_s
+        "#{start.hour}:00:00 - #{start.hour}:59:59"
+      end
+    end
+  end
+end

data/lib/double_entry/reporting/line_aggregate.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class LineAggregate < ActiveRecord::Base
+      def self.aggregate(function:, account:, partner_account:, code:, range:, named_scopes:)
+        collection_filter = LineAggregateFilter.new(account: account, partner_account: partner_account,
+                                                    code: code, range: range, filter_criteria: named_scopes)
+        collection = collection_filter.filter
+        collection.send(function, :amount)
+      end
+
+      def key
+        "#{year}:#{month}:#{week}:#{day}:#{hour}"
+      end
+    end
+  end
+end

data/lib/double_entry/reporting/line_aggregate_filter.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class LineAggregateFilter
+
+      def initialize(account:, partner_account:, code:, range:, filter_criteria:)
+        @account         = account
+        @partner_account = partner_account
+        @code            = code
+        @range           = range
+        @filter_criteria = filter_criteria || []
+      end
+
+      def filter
+        @collection ||= apply_filters
+      end
+
+    private
+
+      def apply_filters
+        collection = apply_filter_criteria.
+                     where(:account => @account).
+                     where(:created_at => @range.start..@range.finish)
+        collection = collection.where(:code => @code) if @code
+        collection = collection.where(:partner_account => @partner_account) if @partner_account
+
+        collection
+      end
+
+      # a lot of the trickier reports will use filters defined
+      # in filter_criteria to bring in data from other tables.
+      # For example:
+      #
+      #   filter_criteria = [
+      #     # an example of calling a named scope called with arguments
+      #     {
+      #       :scope => {
+      #         :name => :ten_dollar_purchases_by_category,
+      #         :arguments => [:cat_videos, :cat_pictures]
+      #       }
+      #     },
+      #     # an example of calling a named scope with no arguments
+      #     {
+      #       :scope => {
+      #         :name => :ten_dollar_purchases
+      #       }
+      #     },
+      #     # an example of providing multiple metadatum criteria to filter on
+      #     {
+      #       :metadata => {
+      #         :meme => :business_cat,
+      #         :category => :fun_times,
+      #       }
+      #     }
+      #   ]
+      def apply_filter_criteria
+        @filter_criteria.reduce(DoubleEntry::Line) do |collection, filter|
+          if filter[:scope].present?
+            filter_by_scope(collection, filter[:scope])
+          elsif filter[:metadata].present?
+            filter_by_metadata(collection, filter[:metadata])
+          else
+            collection
+          end
+        end
+      end
+
+      def filter_by_scope(collection, scope)
+        collection.public_send(scope[:name], *scope[:arguments])
+      end
+
+      def filter_by_metadata(collection, metadata)
+        DoubleEntry::Reporting::LineMetadataFilter.filter(collection: collection, metadata: metadata)
+      end
+    end
+  end
+end

data/lib/double_entry/reporting/line_metadata_filter.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class LineMetadataFilter
+
+      def self.filter(collection:, metadata:)
+        table_alias_index = 0
+
+        metadata.reduce(collection) do |filtered_collection, (key, value)|
+          table_alias = "m#{table_alias_index}"
+          table_alias_index += 1
+
+          filtered_collection.
+            joins("INNER JOIN #{line_metadata_table} as #{table_alias} ON #{table_alias}.line_id = #{lines_table}.id").
+            where("#{table_alias}.key = ? AND #{table_alias}.value = ?", key, value)
+        end
+      end
+
+    private
+
+      def self.line_metadata_table
+        DoubleEntry::LineMetadata.table_name
+      end
+      private_class_method :line_metadata_table
+
+      def self.lines_table
+        DoubleEntry::Line.table_name
+      end
+      private_class_method :lines_table
+
+    end
+  end
+end

data/lib/double_entry/reporting/month_range.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class MonthRange < TimeRange
+      class << self
+        def from_time(time)
+          new(:year => time.year, :month => time.month)
+        end
+
+        def current
+          from_time(Time.now)
+        end
+
+        # Obtain a sequence of MonthRanges from the given start to the current
+        # month.
+        #
+        # @option options :from [Time] Time of the first in the returned sequence
+        #   of MonthRanges.
+        # @return [Array<MonthRange>]
+        def reportable_months(options = {})
+          month = options[:from] ? from_time(options[:from]) : earliest_month
+          last = current
+          [month].tap do |months|
+            while month != last
+              month = month.next
+              months << month
+            end
+          end
+        end
+
+        def earliest_month
+          from_time(Reporting.configuration.start_of_business)
+        end
+      end
+
+      attr_reader :year, :month
+
+      def initialize(options = {})
+        super options
+
+        if options.present?
+          @month = options[:month]
+
+          month_start = Time.local(year, options[:month], 1)
+          @start = month_start
+          @finish = month_start.end_of_month
+
+          @start = MonthRange.earliest_month.start if options[:range_type] == :all_time
+        end
+      end
+
+      def previous
+        if month <= 1
+          MonthRange.new :year => year - 1, :month => 12
+        else
+          MonthRange.new :year => year, :month => month - 1
+        end
+      end
+
+      def next
+        if month >= 12
+          MonthRange.new :year => year + 1, :month => 1
+        else
+          MonthRange.new :year => year, :month => month + 1
+        end
+      end
+
+      def beginning_of_financial_year
+        first_month_of_financial_year = Reporting.configuration.first_month_of_financial_year
+        year = (month >= first_month_of_financial_year) ? @year : (@year - 1)
+        MonthRange.new(:year => year, :month => first_month_of_financial_year)
+      end
+
+      alias_method :succ, :next
+
+      def <=>(other)
+        start <=> other.start
+      end
+
+      def ==(other)
+        month == other.month &&
+          year == other.year
+      end
+
+      def all_time
+        MonthRange.new(:year => year, :month => month, :range_type => :all_time)
+      end
+
+      def to_s
+        start.strftime('%Y, %b')
+      end
+    end
+  end
+end

data/lib/double_entry/reporting/time_range.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module DoubleEntry
+  module Reporting
+    class TimeRange
+      attr_reader :start, :finish
+      attr_reader :year, :month, :week, :day, :hour, :range_type
+
+      def self.make(options = {})
+        @options = options
+        case
+        when options[:year] && options[:week] && options[:day] && options[:hour]
+          HourRange.new(options)
+        when options[:year] && options[:week] && options[:day]
+          DayRange.new(options)
+        when options[:year] && options[:week]
+          WeekRange.new(options)
+        when options[:year] && options[:month]
+          MonthRange.new(options)
+        when options[:year]
+          YearRange.new(options)
+        else
+          fail "Invalid range information #{options}"
+        end
+      end
+
+      def self.range_from_time_for_period(start_time, period_name)
+        case period_name
+        when 'month'
+          YearRange.from_time(start_time)
+        when 'week'
+          YearRange.from_time(start_time)
+        when 'day'
+          MonthRange.from_time(start_time)
+        when 'hour'
+          DayRange.from_time(start_time)
+        end
+      end
+
+      def include?(time)
+        time >= @start &&
+          time <= @finish
+      end
+
+      def initialize(options)
+        @year = options[:year]
+        @range_type = options[:range_type] || :normal
+        @month = @week = @day = @hour = nil
+      end
+
+      def key
+        "#{@year}:#{@month}:#{@week}:#{@day}:#{@hour}"
+      end
+
+      def human_readable_name
+        self.class.name.gsub('DoubleEntry::Reporting::', '').gsub('Range', '')
+      end
+    end
+  end
+end