fios 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5ff8ffbda61ee750118e319d3110463fe4576d9a90dc012d63e3ff49b5c2087
-  data.tar.gz: 381c885fb7ce89220177ccb6ef939589c1ee92f47c0472dcf8f3e3799e7cba31
+  metadata.gz: c65af31bd0d116984a3feb0410ce53348171b425bf5e0d07dd45f00a49a8bf5b
+  data.tar.gz: b3b3292ba5c877af0bdf3d39258a7d5c2c2f177efe5e6a657ef1ee6c72dc44d8
 SHA512:
-  metadata.gz: a26e8780e628d7d60db56a6a567d463daba8362d7060de4ad6c313032801a184b06034aaebc7e75fef11c9f58f203128939aa4f286f295f51115734fac9a3c82
-  data.tar.gz: 382d2090dd248d4c690ec8d7529c37af7d4cf70c66e6ebc12a5aac4c246143bbd5dc171724bf7f7bdaf2c2ce9b6dbf820814bb0f917ceedd15a351e9499f2af3
+  metadata.gz: 90059e0ae8e22cb45bc602c267381501c7786d7ce77520c2ea3faf639c9d496efea1f7ef673f34cfb3b55a656ba730171a2bd8d09258af153347e4ecb62f81de
+  data.tar.gz: 6dd0c0e6aa80bcd9baec5b1ae987ded80477d4aa9dcb654dfcd04c56a74fad68adfb5f9d0dc92953f881ac8952260d9bf322defa3bd3a2fc060d85dac61f448d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fios (0.1.0)
+    fios (1.0.1)
       rails (>= 6.1)
 
 GEM

data/fios.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["Mark Harbison"]
   spec.email = ["mark@tyne-solutions.com"]
 
-  spec.summary = "Fios."
-  spec.description = "Fios."
+  spec.summary = "A data analytics framework for building charts, dashboards, and reports in Ruby."
+  spec.description = "A data analytics framework for building charts, dashboards, and reports in Ruby."
   spec.homepage = "https://github.com/CodeTectonics/fios"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.2.0"

data/lib/fios/adapters/active_record/chart_query.rb

@@ -0,0 +1,106 @@
+module Fios
+  module Adapters
+    module ActiveRecord
+      class ChartQuery
+        def self.add_select_clause(query, chart_config)
+          fields = []
+          fields << chart_config['x_axis']['attr']
+
+          chart_config['y_axes'].each do |column|
+            aggregate = aggregated_attr(column['attr'], column['aggregation'])
+            fields << "#{aggregate[0]} AS '#{aggregate[1]}'"
+          end
+
+          query.select(fields)
+        end
+
+        def self.aggregated_attr(attr, aggregation)
+          case aggregation
+          when 'count'
+            ["COUNT(#{attr})", "num_#{attr}"]
+          when 'count_distinct'
+            ["COUNT(DISTINCT #{attr})", "num_uniq_#{attr}"]
+          when 'average'
+            ["AVG(#{attr})", "avg_#{attr}"]
+          when 'min'
+            ["MIN(#{attr})", "min_#{attr}"]
+          when 'max'
+            ["MAX(#{attr})", "max_#{attr}"]
+          when 'sum'
+            ["SUM(#{attr})", "sum_#{attr}"]
+          else
+            attr
+          end
+        end
+
+        def self.add_where_clause(query, chart_config)
+          return query if chart_config['filters'].blank?
+
+          chart_config['filters'].each do |filter|
+            field = filter['attr']
+            operator = filter['operator']
+            value = filter['value']
+
+            case operator
+            when '='
+              query = query.where(field => value)
+            when '!='
+              query = query.where.not(field => value)
+            when '>'
+              query = query.where("#{field} > ?", value)
+            when '>='
+              query = query.where("#{field} >= ?", value)
+            when '<'
+              query = query.where("#{field} < ?", value)
+            when '<='
+              query = query.where("#{field} <= ?", value)
+            when 'contains'
+              query = query.where("#{field} LIKE ?", "%#{value}%")
+            when 'starts_with'
+              query = query.where("#{field} LIKE ?", "#{value}%")
+            when 'ends_with'
+              query = query.where("#{field} LIKE ?", "%#{value}")
+            when 'one_of'
+              query = query.where("#{field} IN (?)", value)
+            when 'not_one_of'
+              query = query.where.not("#{field} IN (?)", value)
+            end
+          end
+
+          query
+        end
+
+        def self.add_group_clause(query, chart_config)
+          group_field = chart_config['x_axis']['attr']
+          query.group(group_field)
+        end
+
+        def self.parse_series_data(data, chart_config)
+          return [] if data.empty?
+
+          attrs = data[0].attribute_names
+          attrs.delete(chart_config['x_axis']['attr'])
+
+          attrs.map do |attr|
+            y_axis = chart_config['y_axes'].find do |col|
+              attr == aggregated_attr(col['attr'], col['aggregation'])[1]
+            end
+
+            { name: y_axis['label'], data: data.pluck(attr) }
+          end
+        end
+
+        def self.parse_category_data(data, chart_config, data_source)
+          x_axis_attr = chart_config['x_axis']['attr']
+
+          translatable = data_source.translated_columns.include?(x_axis_attr.to_sym)
+          data.map do |row|
+            return row[x_axis_attr] unless translatable
+
+            I18n.t(row[x_axis_attr], default: row[x_axis_attr])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fios/adapters/active_record/report_query.rb

@@ -0,0 +1,88 @@
+module Fios
+  module Adapters
+    module ActiveRecord
+      class ReportQuery
+        def self.add_select_clause(query, data_source, report_config)
+          fields = []
+          report_config['columns'].each do |column|
+            next unless column['selected']
+
+            if report_config['aggregated']
+              fields << column['name'] if column['group_by']
+              fields << "COUNT(#{column['name']}) AS 'num_#{column['name']}'" if column['count']
+              if column['count_distinct']
+                fields << "COUNT(DISTINCT #{column['name']}) AS 'num_uniq_#{column['name']}'"
+              end
+              if column['average']
+                if column['type'].in?(%w[date datetime])
+                  fields << "FROM_UNIXTIME(AVG(UNIX_TIMESTAMP(#{column['name']}))) AS 'avg_#{column['name']}'"
+                else
+                  fields << "AVG(#{column['name']}) AS 'avg_#{column['name']}'"
+                end
+              end
+              fields << "MIN(#{column['name']}) AS 'min_#{column['name']}'" if column['min']
+              fields << "MAX(#{column['name']}) AS 'max_#{column['name']}'" if column['max']
+              fields << "SUM(#{column['name']}) AS 'sum_#{column['name']}'" if column['sum']
+            else
+              fields << column['name']
+            end
+          end
+
+          fields = data_source.column_names if fields.empty?
+
+          query.select(fields)
+        end
+
+        def self.add_where_clause(query, report_config)
+          return query if report_config['filters'].blank?
+
+          report_config['filters'].each do |filter|
+            field = filter['name']
+            operator = filter['operator']
+            value = filter['value']
+
+            case operator
+            when '='
+              query = query.where(field => value)
+            when '!='
+              query = query.where.not(field => value)
+            when '>'
+              query = query.where("#{field} > ?", value)
+            when '>='
+              query = query.where("#{field} >= ?", value)
+            when '<'
+              query = query.where("#{field} < ?", value)
+            when '<='
+              query = query.where("#{field} <= ?", value)
+            when 'contains'
+              query = query.where("#{field} LIKE ?", "%#{value}%")
+            when 'starts_with'
+              query = query.where("#{field} LIKE ?", "#{value}%")
+            when 'ends_with'
+              query = query.where("#{field} LIKE ?", "%#{value}")
+            when 'one_of'
+              query = query.where("#{field} IN (?)", value)
+            when 'not_one_of'
+              query = query.where.not("#{field} IN (?)", value)
+            end
+          end
+
+          query
+        end
+
+        def self.add_group_clause(query, report_config)
+          return query unless report_config['aggregated']
+
+          group_fields = []
+          report_config['columns'].each do |column|
+            next unless column['selected'] && column['group_by']
+
+            group_fields << column['name']
+          end
+
+          query.group(group_fields)
+        end
+      end
+    end
+  end
+end

data/lib/fios/adapters/active_record_adapter.rb

@@ -7,15 +7,32 @@ module Fios
         :active_record
       end
 
-      def initialize(dataset)
-        @dataset = dataset
-        @definition = Fios::Definitions::Registry.fetch(dataset.slug)
+      def self.fetch_chart_data(data_source, chart)
+        chart_config = chart.configuration
+
+        query = data_source.all
+        query = Fios::Adapters::ActiveRecord::ChartQuery.add_select_clause(query, chart_config)
+        query = Fios::Adapters::ActiveRecord::ChartQuery.add_where_clause(query, chart_config)
+        query = Fios::Adapters::ActiveRecord::ChartQuery.add_group_clause(query, chart_config)
+        data = query.to_a
+
+        {
+          series: Fios::Adapters::ActiveRecord::ChartQuery.parse_series_data(data, chart_config),
+          categories: Fios::Adapters::ActiveRecord::ChartQuery.parse_category_data(data, chart_config, data_source),
+          meta: {
+            title: chart.name,
+            chart_type: chart_config['chart_type']
+          }
+        }
       end
 
-      # TODO
-      def fetch(filters:, limit:)
-        view = @definition.source
-        # build SQL using filters + metadata
+      def self.fetch_report_data(data_source, report)
+        report_config = report.configuration
+
+        query = data_source.all
+        query = Fios::Adapters::ActiveRecord::ReportQuery.add_select_clause(query, data_source, report_config)
+        query = Fios::Adapters::ActiveRecord::ReportQuery.add_where_clause(query, report_config)
+        Fios::Adapters::ActiveRecord::ReportQuery.add_group_clause(query, report_config)
       end
     end
   end

data/lib/fios/adapters/base.rb

@@ -3,16 +3,18 @@ module Fios
     module Base
       extend ActiveSupport::Concern
 
-      attr_accessor :dataset, :definition
-
       class_methods do
         def adapter_key
           raise NotImplementedError
         end
-      end
 
-      def fetch(filters:, limit:)
-        raise NotImplementedError
+        def fetch_chart_data(data_source, chart)
+          raise NotImplementedError
+        end
+
+        def fetch_report_data(data_source, report)
+          raise NotImplementedError
+        end
       end
     end
   end

data/lib/fios/builders/chart_builder.rb

@@ -2,31 +2,28 @@ module Fios
   module Builders
     class ChartBuilder
       def self.build(chart)
+        data = fetch_data(chart)
+        parse_query_results(data)
+      end
+
+      def self.fetch_data(chart)
         chart_config = chart.configuration || {}
         dataset = Dataset.find(chart_config['dataset_id'])
-        dataset_class = Fios::Services::DatasetFetcher.fetch(dataset)
-
-        query = dataset_class.all
-        query = add_select_clause(query, chart_config)
-        query = add_where_clause(query, chart_config)
-        query = add_group_clause(query, chart_config)
-        parse_query_results(query, chart)
+        Fios::Services::DatasetFetcher.fetch_chart_data(dataset, chart)
       end
 
-      def self.parse_query_results(query, chart)
-        data = query.to_a
-
+      def self.parse_query_results(data)
         {
           'chart': {
-            'type': chart.configuration['chart_type']
+            'type': data[:meta][:chart_type]
           },
 
           'title': {
-            'text': chart.name
+            'text': data[:meta][:title]
           },
 
           'xAxis': {
-            'categories': parse_category_data(data, chart.configuration)
+            'categories': data[:categories]
           },
 
           'yAxis': {
@@ -35,116 +32,14 @@ module Fios
             }
           },
 
-          'series': parse_series_data(data, chart.configuration)
+          'series': data[:series]
         }
       end
 
-      def self.parse_category_data(data, chart_config)
-        x_axis_attr = chart_config['x_axis']['attr']
-
-        dataset = Dataset.find(chart_config['dataset_id'])
-        dataset_class = Fios::Services::DatasetFetcher.fetch(dataset)
-
-        translatable = dataset_class.translated_columns.include?(x_axis_attr.to_sym)
-        data.map do |row|
-          return row[x_axis_attr] unless translatable
-
-          I18n.t(row[x_axis_attr], default: row[x_axis_attr])
-        end
-      end
-
-      def self.parse_series_data(data, chart_config)
-        return [] if data.empty?
-
-        attrs = data[0].attribute_names
-        attrs.delete(chart_config['x_axis']['attr'])
-
-        attrs.map do |attr|
-          y_axis = chart_config['y_axes'].find do |col|
-            attr == aggregated_attr(col['attr'], col['aggregation'])[1]
-          end
-
-          { name: y_axis['label'], data: data.pluck(attr) }
-        end
-      end
-
-      def self.add_select_clause(query, chart_config)
-        fields = []
-        fields << chart_config['x_axis']['attr']
-
-        chart_config['y_axes'].each do |column|
-          aggregate = aggregated_attr(column['attr'], column['aggregation'])
-          fields << "#{aggregate[0]} AS '#{aggregate[1]}'"
-        end
-
-        query.select(fields)
-      end
-
-      def self.aggregated_attr(attr, aggregation)
-        case aggregation
-        when 'count'
-          ["COUNT(#{attr})", "num_#{attr}"]
-        when 'count_distinct'
-          ["COUNT(DISTINCT #{attr})", "num_uniq_#{attr}"]
-        when 'average'
-          ["AVG(#{attr})", "avg_#{attr}"]
-        when 'min'
-          ["MIN(#{attr})", "min_#{attr}"]
-        when 'max'
-          ["MAX(#{attr})", "max_#{attr}"]
-        when 'sum'
-          ["SUM(#{attr})", "sum_#{attr}"]
-        else
-          attr
-        end
-      end
-
-      def self.add_where_clause(query, chart_config)
-        return query if chart_config['filters'].blank?
-
-        chart_config['filters'].each do |filter|
-          field = filter['attr']
-          operator = filter['operator']
-          value = filter['value']
-
-          case operator
-          when '='
-            query = query.where(field => value)
-          when '!='
-            query = query.where.not(field => value)
-          when '>'
-            query = query.where("#{field} > ?", value)
-          when '>='
-            query = query.where("#{field} >= ?", value)
-          when '<'
-            query = query.where("#{field} < ?", value)
-          when '<='
-            query = query.where("#{field} <= ?", value)
-          when 'contains'
-            query = query.where("#{field} LIKE ?", "%#{value}%")
-          when 'starts_with'
-            query = query.where("#{field} LIKE ?", "#{value}%")
-          when 'ends_with'
-            query = query.where("#{field} LIKE ?", "%#{value}")
-          when 'one_of'
-            query = query.where("#{field} IN (?)", value)
-          when 'not_one_of'
-            query = query.where.not("#{field} IN (?)", value)
-          end
-        end
-
-        query
-      end
-
-      def self.add_group_clause(query, chart_config)
-        group_field = chart_config['x_axis']['attr']
-        query.group(group_field)
-      end
-
       def self.build_csv(chart)
         {
           headers: csv_headers(chart),
-          rows: build(chart)
+          rows: fetch_data(chart)
         }
       end
 

data/lib/fios/builders/report_builder.rb

@@ -1,111 +1,28 @@
 module Fios
   module Builders
     class ReportBuilder
-      def self.build(dynamic_report)
-        report_config = dynamic_report.configuration || {}
-
-        dataset = Dataset.find(report_config['dataset_id'])
-        dataset_class = Fios::Services::DatasetFetcher.fetch(dataset)
-
-        query = dataset_class.all
-        query = add_select_clause(query, dataset_class, report_config)
-        query = add_where_clause(query, report_config)
-        add_group_clause(query, report_config)
-      end
-
-      def self.add_select_clause(query, dataset_class, report_config)
-        fields = []
-        report_config['columns'].each do |column|
-          next unless column['selected']
-
-          if report_config['aggregated']
-            fields << column['name'] if column['group_by']
-            fields << "COUNT(#{column['name']}) AS 'num_#{column['name']}'" if column['count']
-            if column['count_distinct']
-              fields << "COUNT(DISTINCT #{column['name']}) AS 'num_uniq_#{column['name']}'"
-            end
-            if column['average']
-              if column['type'].in?(%w[date datetime])
-                fields << "FROM_UNIXTIME(AVG(UNIX_TIMESTAMP(#{column['name']}))) AS 'avg_#{column['name']}'"
-              else
-                fields << "AVG(#{column['name']}) AS 'avg_#{column['name']}'"
-              end
-            end
-            fields << "MIN(#{column['name']}) AS 'min_#{column['name']}'" if column['min']
-            fields << "MAX(#{column['name']}) AS 'max_#{column['name']}'" if column['max']
-            fields << "SUM(#{column['name']}) AS 'sum_#{column['name']}'" if column['sum']
-          else
-            fields << column['name']
-          end
-        end
-
-        fields = dataset_class.column_names if fields.empty?
-
-        query.select(fields)
+      def self.build(report)
+        fetch_data(report)
       end
 
-      def self.add_where_clause(query, report_config)
-        return query if report_config['filters'].blank?
-
-        report_config['filters'].each do |filter|
-          field = filter['name']
-          operator = filter['operator']
-          value = filter['value']
-
-          case operator
-          when '='
-            query = query.where(field => value)
-          when '!='
-            query = query.where.not(field => value)
-          when '>'
-            query = query.where("#{field} > ?", value)
-          when '>='
-            query = query.where("#{field} >= ?", value)
-          when '<'
-            query = query.where("#{field} < ?", value)
-          when '<='
-            query = query.where("#{field} <= ?", value)
-          when 'contains'
-            query = query.where("#{field} LIKE ?", "%#{value}%")
-          when 'starts_with'
-            query = query.where("#{field} LIKE ?", "#{value}%")
-          when 'ends_with'
-            query = query.where("#{field} LIKE ?", "%#{value}")
-          when 'one_of'
-            query = query.where("#{field} IN (?)", value)
-          when 'not_one_of'
-            query = query.where.not("#{field} IN (?)", value)
-          end
-        end
-
-        query
-      end
-
-      def self.add_group_clause(query, report_config)
-        return query unless report_config['aggregated']
-
-        group_fields = []
-        report_config['columns'].each do |column|
-          next unless column['selected'] && column['group_by']
-
-          group_fields << column['name']
-        end
-
-        query.group(group_fields)
+      def self.fetch_data(report)
+        report_config = report.configuration || {}
+        dataset = Dataset.find(report_config['dataset_id'])
+        Fios::Services::DatasetFetcher.fetch_report_data(dataset, report)
       end
 
-      def self.build_csv(dynamic_report)
+      def self.build_csv(report)
         {
-          headers: csv_headers(dynamic_report),
-          rows: build(dynamic_report)
+          headers: csv_headers(report),
+          rows: fetch_data(report)
         }
       end
 
-      def self.csv_headers(dynamic_report)
-        report_config = dynamic_report.configuration || {}
+      def self.csv_headers(report)
+        report_config = report.configuration || {}
 
         dataset = Dataset.find(report_config['dataset_id'])
-        dataset_class = Fios::Services::DatasetFetcher.fetch(dataset)
+        dataset_class = Fios::Services::DatasetFetcher.fetch_report_data(dataset, report)
 
         return dataset_class.column_names if report_config['columns'].blank?
 

data/lib/fios/services/dataset_fetcher.rb

@@ -1,11 +1,16 @@
 module Fios
   module Services
     class DatasetFetcher
-      def self.fetch(dataset)
-        adapter_klass = Fios::Adapters::Registry.fetch(dataset.adapter)
-        adapter = adapter_klass.new(dataset)
-        adapter.definition
-        #adapter.fetch()
+      def self.fetch_chart_data(dataset, chart)
+        adapter = Fios::Adapters::Registry.fetch(dataset.adapter)
+        data_source = Fios::Definitions::Registry.fetch(dataset.slug)
+        data = adapter.fetch_chart_data(data_source, chart)
+      end
+
+      def self.fetch_report_data(dataset, report)
+        adapter = Fios::Adapters::Registry.fetch(dataset.adapter)
+        data_source = Fios::Definitions::Registry.fetch(dataset.slug)
+        data = adapter.fetch_report_data(data_source, report)
       end
     end
   end

data/lib/fios/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fios
-  VERSION = "0.1.0"
+  VERSION = "1.0.1"
 end

data/lib/fios.rb

@@ -5,6 +5,8 @@ require "active_support/concern"
 require "rails"
 
 require_relative "fios/adapters/base"
+require_relative "fios/adapters/active_record/chart_query"
+require_relative "fios/adapters/active_record/report_query"
 require_relative "fios/adapters/active_record_adapter"
 require_relative "fios/adapters/registry"
 require_relative "fios/builders/chart_builder"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fios
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Mark Harbison
@@ -24,7 +24,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.1'
-description: Fios.
+description: A data analytics framework for building charts, dashboards, and reports
+  in Ruby.
 email:
 - mark@tyne-solutions.com
 executables: []
@@ -45,6 +46,8 @@ files:
 - bin/setup
 - fios.gemspec
 - lib/fios.rb
+- lib/fios/adapters/active_record/chart_query.rb
+- lib/fios/adapters/active_record/report_query.rb
 - lib/fios/adapters/active_record_adapter.rb
 - lib/fios/adapters/base.rb
 - lib/fios/adapters/registry.rb
@@ -84,7 +87,8 @@ requirements: []
 rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
-summary: Fios.
+summary: A data analytics framework for building charts, dashboards, and reports in
+  Ruby.
 test_files:
 - spec/fios_spec.rb
 - spec/spec_helper.rb