has_helpers 5.0.2

data/app/commands/reports/base_options.rb

@@ -0,0 +1,79 @@
+# typed: true
+# frozen_string_literal: true
+
+module Reports
+  module BaseOptions
+    def self.generate_select_options(klass, resource_id, **_options)
+      base_attributes(klass).flat_map do |attr, column_type_name|
+        expansions = [
+          {}, # Create a non-expanded option
+          # *attr.column.expand_on
+        ]
+
+        expansions.map do |_expansion|
+          column_type = column_type_name.to_s
+          # expanded_column_name = expansion[:column_name]
+          # expanded_value       = expansion[:value]
+          # expand_on_nil        = expansion[:allow_nil]
+
+          {
+            name: attr.name,
+            columnType: column_type,
+            associationColumnName: attr.name,
+            resourceId: resource_id,
+          }
+        end
+      end
+    end
+
+    def self.generate_filter_options(klass, **_options)
+      base_attributes(klass).reject do |_attr, column_type|
+        # Skip JSON columns because we don't generate filter options for those
+        [::Flattener::Column::Types::JSON].include?(column_type)
+      end.
+        flat_map do |attr, column_type_name|
+        expansions = [
+          {}, # Create a non-expanded option
+          # *attr.column.expand_on
+        ]
+
+        expansions.map do |_expansion|
+          column_type = column_type_name.to_s
+
+          ::Reports::FilterOptionGenerator.for(column_type_name).new(
+            flattener_attr: nil,
+            attr: attr.name,
+            name: ::Reports::Generator.build_option_name(attr.name, column_type: column_type, preserve_id: true)
+          ).generate
+          #   option[:partialType] = nil #attr.column.partial_type_id if attr.column.partial_type TODO need to check for a method to get the partial type id
+          # end
+        end
+      end
+    end
+
+    # Returns a lazy enumerator which yields the base attributes (only those available for reports) for the given class.
+    def self.base_attributes(klass)
+      flattener_klass = Flattener.for(klass).pivot_or_self
+
+      flattener_klass.new.flatten.lazy.
+        select do |attr|
+        is_base_option?(attr)
+      end.
+        map do |attr|
+        # determine column type for each attribute
+        [attr, attr.column.type]
+      end.
+        reject do |_attr, column_type|
+        # Remove attributes which have a date or datetime type. These are handled as belongs_to relations.
+        # Also, skip JSON columns because we don't generate select options for those
+        [::Flattener::Column::Types::DATE, ::Flattener::Column::Types::DATETIME].include?(column_type)
+      end
+    end
+
+    def self.is_base_option?(attr)
+      attr.column_association.nil? &&
+        !(attr.resource.is_constant? && attr.column.name == "name") &&
+        !::Reports::NestedAttributeOptions.is_nested?(attr)
+    end
+  end
+end

data/app/commands/reports/belongs_to_options.rb

@@ -0,0 +1,178 @@
+# typed: true
+# frozen_string_literal: true
+
+module Reports
+  module BelongsToOptions
+    def self.generate_select_options(
+      klass,
+      nested_as: nil,
+      **_options
+    )
+      Enumerator.new do |yielder|
+        # Yield a select option for each belongs to association
+        belongs_to_associations(klass).
+          each do |association|
+            foreign_key = association.foreign_key
+            column = klass.columns_hash[foreign_key] # Physical column in the DB
+            nullable = !column || column.null
+            join_type = nullable ? "Left" : "Inner"
+            association_and_descendants(association).each do |association_klass, association_name|
+              response = Reports::ExternalGraphqlClient.query_resource_by_name(name: association_klass.name.demodulize)
+              association_resource_id = response.dig("data", "resourceName", "id")
+              yielder << {
+                name:                    ::Reports::Generator.build_option_name(*nested_as, association_name),
+                selectOptionType:        "BelongsTo",
+                columnType:              "link",
+                associationResourceId:   association_resource_id.to_i,
+                associationName:         association_name,
+                associationColumnName:   [*nested_as, foreign_key].join("_"),
+                joinType:                join_type
+              }
+            end
+          end
+        # Also generate a select option for each base attribute which is a date or datetime.
+        date_resource = Reports::ExternalGraphqlClient.query_resource_by_name(name: "DwDate")
+        date_resource_id = date_resource.dig("data", "resourceName", "id")
+        if date_resource
+          date_options = date_attributes(klass).map do |key|
+            attr = key[:name]
+            column_type = key[:column_type]
+            {
+              name: "#{::Reports::Generator.build_option_name(*nested_as, attr)} Date",
+              selectOptionType: "BelongsTo",
+              columnType: column_type.to_s,
+              associationResourceId: date_resource_id.to_i,
+              associationName: attr,
+              associationColumnName: attr,
+              joinType: "Left",
+            }
+          end.to_a
+          date_options.each { |option| yielder << option }
+          date_cast_options(date_options).each { |option| yielder << option }
+        end
+      end
+    end
+
+    def self.generate_filter_options(
+      klass,
+      resource_id,
+      nested_as: nil,
+      **_options
+    )
+      klass_name = klass.name.demodulize
+      Enumerator.new do |yielder|
+        # Yield a filter option for the base table.  (For filters, this behaves like a Belongs To filter option)
+        if base_resources(klass)
+          yielder << {
+            name: klass_name,
+            filterOptionType: "BelongsTo",
+            associationResourceId: resource_id.to_i,
+            associationName: klass.name.underscore,
+            associationColumnName: "id",
+          }
+        end
+        # Yield a filter option for each belongs to association
+        belongs_to_associations(klass).each do |association|
+          foreign_key = association.foreign_key
+          column = klass.columns_hash[foreign_key]
+          nullable = !column || column.null
+          join_type = nullable ? "Left" : "Inner"
+          association_and_descendants(association).each do |association_klass, association_name|
+            response = Reports::ExternalGraphqlClient.query_resource_by_name(name: association_klass.name.demodulize)
+            association_resource_id = response.dig("data", "resourceName", "id")
+            yielder << {
+              name: ::Reports::Generator.build_option_name(*nested_as, association_name),
+              filterOptionType: "BelongsTo",
+              associationResourceId: association_resource_id.to_i,
+              associationName: association_name,
+              associationColumnName: [*nested_as, association.foreign_key].join("_"),
+              joinType: join_type,
+            }
+          end
+        end
+        date_resource = Reports::ExternalGraphqlClient.query_resource_by_name(name: "DwDate")
+        date_resource_id = date_resource.dig("data", "resourceName", "id")
+        if date_resource
+          date_options = date_attributes(klass).map do |key|
+            attr = key[:name]
+            column_type = key[:column_type]
+            {
+              name: "#{::Reports::Generator.build_option_name(*nested_as, attr)} Date",
+              filterOptionType: "BelongsTo",
+              columnType: column_type.to_s,
+              associationResourceId: date_resource_id.to_i,
+              associationName: attr,
+              associationColumnName: attr,
+              joinType: "Left",
+            }
+          end.to_a
+          date_options.each { |option| yielder << option }
+          date_cast_options(date_options).each { |option| yielder << option }
+        end
+      end
+    end
+
+    # Returns a lazy enumerator which yields the belongs_to associations (only those available for reports) for the given class.
+    def self.belongs_to_associations(klass)
+      flattener(klass).associations.
+        reject(&:is_constant?).
+        select { |association| association.macro == :belongs_to }.
+        reject { |association| association.flattener.class.is_pivot? }
+    end
+
+    def self.flattener(klass)
+      Flattener.for(klass).pivot_or_self
+    end
+
+    def self.base_resources(klass)
+      ::HasHelpers::Resource.where(
+        name: klass.name.demodulize,
+        resource_type: ::HasHelpers::ResourceType.where(name: "Base")
+      ).exists?
+    end
+
+    def self.association_and_descendants(association)
+      [
+        [association.klass, association.name.to_s],
+        *association.klass.descendants.map { |d| [d, format_descendent_name(d, association)] }
+      ]
+    end
+
+    # Returns a lazy enumerator which yields the base attributes (only those available for reports) for the given class.
+    def self.date_attributes(klass)
+      model = klass.is_a?(Class) ? klass : klass.class
+
+      model.columns.map do |column|
+        sql_type = ::Flattener::Column::Types.sql_type_to_type(column.sql_type)
+        {
+          name: column.name,
+          column_type: sql_type,
+          source: model.name
+        }
+      end.select do |attr_info|
+        ["date", "datetime"].include?(attr_info[:column_type].to_s)
+      end
+    end
+
+    def self.date_cast_options(date_options)
+      date_options.lazy.select { |option| option[:column_type] == "datetime" }.map do |option|
+        date_time_cast_name = ::Reports::Generator.build_option_name(option[:name].sub(/\sat$/i, ""), "date")
+        next if date_options.any? { |o| o[:name] == date_time_cast_name }
+        option.merge(
+          name: date_time_cast_name,
+          column_type: "date_cast",
+        )
+      end.reject(&:nil?)
+    end
+
+    # To avoid naming conflicts, suffix the descendant's name with the association
+    # unless the association's name matches the association's klass name
+    def self.format_descendent_name(descendant, association)
+      if association.name.to_s.classify == association.klass.name.demodulize
+        descendant.name.underscore
+      else
+        "#{descendant.name.underscore}_#{association.name}"
+      end
+    end
+  end
+end

data/app/commands/reports/constant_options.rb

@@ -0,0 +1,66 @@
+# typed: false
+# frozen_string_literal: true
+
+module Reports
+  module ConstantOptions
+    def self.generate_select_options(klass, **_options)
+      generate_options(klass, "select")
+    end
+
+    def self.generate_filter_options(klass, **_options)
+      generate_options(klass, "filter")
+    end
+
+    def self.generate_options(klass, type)
+      flattener_klass = Flattener.for(klass).pivot_or_self
+      flattener_klass.flatten.lazy.select { |attr| is_constant?(attr) }.reject do |attr|
+        # Ignore nested attributes (i.e. sales_manager_1_type)
+        ::Reports::NestedAttributeOptions.is_nested?(attr)
+      end.
+        flat_map do |attr|
+        name = ::Reports::Generator.build_option_name(attr.column_association_name)
+        [{
+           name: name,
+           "#{type}OptionType": option_type_id(attr),
+           associationColumnName: attr.name,
+           associationName: constant_klass(attr).name,
+           columnType: nil
+         }].tap do |options|
+          if is_grouped?(attr)
+            options << {
+              name: "#{name} Group",
+              "#{type}OptionType": option_type_id(attr, is_group: true),
+              associationColumnName: attr.name,
+              associationName: constant_klass(attr).name,
+              columnTypeId: nil
+            }
+          end
+        end
+      end
+    end
+
+    def self.constant_klass(attr)
+      attr.column_association.klass
+    end
+
+    def self.is_constant?(attr)
+      attr.column_association&.type == :constant
+    end
+
+    def self.is_grouped?(attr)
+      constant_klass(attr).supports_grouping?
+    end
+
+    def self.is_simple?(attr)
+      constant_klass(attr).simple
+    end
+
+    def self.option_type_id(attr, is_group: false)
+      if is_simple?(attr)
+        is_group ? "SimpleConstantGroup" : "SimpleConstant"
+      else
+        is_group ? "ConstantGroup" : "Constant"
+      end
+    end
+  end
+end

data/app/commands/reports/external_graphql_client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+class Reports::ExternalGraphqlClient
+  GRAPHQL_REPORTS_BACKEND_END_POINT = ENV.fetch("GRAPHQL_REPORTS_BACKEND_END_POINT", "http://127.0.0.1:3005/graphql")
+  APP_NAME_PREFIX = ENV.fetch("APP_NAME_PREFIX", "ReadyGop::")
+
+  def self.create_resource(mutation_name: nil, input_name: nil, attributes: nil)
+    return if mutation_name.nil? || attributes.nil?
+    capitalized_mutation = mutation_name.camelize(:lower)
+
+    # Add the prefix to the name to differentiate between the resources in differente projects for RaaS
+    if mutation_name == "createResource" && attributes[:name].present? && !attributes[:name].to_s.start_with?(APP_NAME_PREFIX)
+      inflection_name = attributes[:name] == "DwDate" ? "DWDate" : attributes[:name]
+      attributes[:name] = "#{APP_NAME_PREFIX}#{inflection_name}"
+    end
+
+    # Define the GraphQL mutation
+    # This is a simple example; adjust the mutation according to your schema
+    mutation = <<~GRAPHQL
+      mutation #{mutation_name}($input: #{input_name}!) {
+        #{capitalized_mutation}(attributes: $input) {
+          resource {
+            id
+          }
+          errors
+        }
+      }
+    GRAPHQL
+    variables = {
+      input: {
+        **attributes
+      }
+    }
+    faraday_post(query: mutation, variables: variables)
+  end
+
+  def self.query_resource_by_name(name: nil, **kwargs)
+    name ||= kwargs[:name] # compatibility with hash
+    name = name == "DwDate" ? "DWDate" : name
+    raise ArgumentError, "missing keyword: :name" if name.nil? || name.to_s.empty?
+    prefixed_name = name&.to_s&.start_with?(APP_NAME_PREFIX) ? name : "#{APP_NAME_PREFIX}#{name}"
+
+    query = <<~GRAPHQL
+      query getResourceByName($name: String!) {
+        resourceName(name: $name)
+      }
+    GRAPHQL
+
+    variables = {
+      name: prefixed_name
+    }
+
+    faraday_post(query: query, variables: variables)
+  end
+
+  def self.query_all_resources
+    query = <<~GRAPHQL
+      query getAllResources {
+        resources {
+          edges {
+            node {
+              id
+              name
+              type
+            }
+          }
+        }
+      }
+    GRAPHQL
+
+    faraday_post(query: query, variables: nil)
+  end
+
+  def self.faraday_post_with_auth(query:, variables: {}, auth_header: nil)
+    faraday_post(query: query, variables: variables, auth_header: auth_header)
+  end
+
+  def self.faraday_post(query:, variables: {}, auth_header: nil)
+    conn = Faraday.new(GRAPHQL_REPORTS_BACKEND_END_POINT, ssl: { verify: false })
+    response = conn.post do |req|
+      req.headers["Content-Type"] = "application/json"
+      req.headers["Authorization"] = auth_header if auth_header.present?
+      req.body = {
+        query: query,
+        variables: variables
+      }.to_json
+    end
+
+    if response.success?
+      parsed_response = JSON.parse(response.body)
+    else
+      parsed_response = { error: "Request failed", status: response.status, body: response.body }
+    end
+
+    # remove the ReadyGop:: prefix from the name in the response to avoid .constantize issues
+    # also set DWDate correctly to avoid inflection issues
+    if parsed_response&.dig("data", "resourceName", "name")&.start_with?(APP_NAME_PREFIX)
+      parsed_response["data"]["resourceName"]["name"] = parsed_response["data"]["resourceName"]["name"].remove(APP_NAME_PREFIX)
+      parsed_response["data"]["resourceName"]["name"] = "DwDate" if parsed_response["data"]["resourceName"]["name"] == "DWDate"
+      # same but for the query_all_resources response
+    elsif parsed_response&.dig("data", "resources", "edges").is_a?(Array)
+      parsed_response["data"]["resources"]["edges"].each do |edge|
+        next if edge["node"].nil?
+
+        if edge["node"]["name"].start_with?(APP_NAME_PREFIX)
+          edge["node"]["name"] = edge["node"]["name"].remove(APP_NAME_PREFIX)
+          edge["node"]["name"] = "DwDate" if edge["node"]["name"] == "DWDate"
+        end
+      end
+    end
+    parsed_response
+  end
+end

data/app/commands/reports/fill_dates.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Reports
+  # ::Reports::FillDates.call to populate the dw_dates table with date records.
+  class FillDates
+    def self.call
+      start_date = Date.new(2015, 1, 1)
+      end_date = Date.new(2030, 1, 1)
+
+      records = []
+
+      (start_date..end_date).each do |date|
+        year = date.year
+        month = date.month
+
+        month_abbreviation = date.strftime("%b")
+        month_name = date.strftime("%B")
+        day = date.day
+        day_of_year = date.yday
+        weekday_name = date.strftime("%A")
+        calendar_week = date.cweek
+        formatted_date = date.strftime("%m/%d/%Y")
+        quarter = ((month - 1) / 3) + 1
+        year_quarter = "#{year}_Q#{quarter}"
+        year_month = "#{year}_#{month_name}"
+        weekend = [6, 7].include?(date.cwday) # ISO: 6=Sat, 7=Sun
+        holiday = %w[0101 0704 1225 1226].include?(date.strftime("%m%d"))
+
+        week_start_date = date - (date.cwday - 1)
+        week_end_date = date + (7 - date.cwday)
+        month_start_date = date.beginning_of_month
+        month_end_date = date.end_of_month
+
+        records << {
+          id: date,
+          year: year,
+          month: month,
+          month_abbreviation: month_abbreviation,
+          month_name: month_name,
+          day: day,
+          day_of_year: day_of_year,
+          weekday_name: weekday_name,
+          calendar_week: calendar_week,
+          formatted_date: formatted_date,
+          quarter: quarter,
+          year_quarter: year_quarter,
+          year_month: year_month,
+          weekend: weekend,
+          holiday: holiday,
+          week_start_date: week_start_date,
+          week_end_date: week_end_date,
+          month_start_date: month_start_date,
+          month_end_date: month_end_date,
+          created_at: Time.current,
+          updated_at: Time.current
+        }
+      end
+
+      # rubocop:disable Rails/SkipsModelValidations
+      DwDate.insert_all!(records)
+      # rubocop:enable Rails/SkipsModelValidations
+      puts "✅ Inserted #{records.size} records into dw_dates"
+    end
+  end
+end

data/app/commands/reports/filter_option_generator.rb

@@ -0,0 +1,186 @@
+# typed: true
+# frozen_string_literal: true
+
+module Reports
+  module FilterOptionGenerator
+    # Where data_type is one of Flattener::Column::Types
+    def self.for(data_type)
+      subclass_name = data_type.to_s.classify
+      const_defined?(subclass_name, false) ? const_get(subclass_name, false) : Base
+    end
+
+    class Base
+      attr_reader :attr, :flattener_attr, :name
+
+      def initialize(
+        flattener_attr:,
+        name_prefix: nil,
+        name_postfix: nil,
+        attr: flattener_attr.name,
+        name: flattener_attr.name,
+        **_options
+      )
+        @attr = attr
+        @flattener_attr = flattener_attr
+        @name = ::Reports::Generator.build_option_name(*name_prefix, name, *name_postfix, preserve_id: true)
+      end
+
+      # Returns the FilterOption attributes
+      def generate(**_options)
+        default_options
+      end
+
+      def default_options(**_options)
+        {
+          name: name,
+          association_column_name: attr
+        }
+      end
+    end
+
+    class Boolean < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "boolean",
+          partialType: "Boolean",
+          operationType: "Equality"
+        }
+      end
+    end
+
+    class Currency < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "currency",
+          partialType: "Currency",
+          operationType: "Numeric"
+        }
+      end
+    end
+
+    class Date < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "date",
+          partialType: "Date",
+          operationType: "Date"
+        }
+      end
+    end
+
+    Datetime = Date # Do we need separate handling for Datetime? *
+
+    class Float < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "float",
+          partialType: "Numeric",
+          operationType: "Numeric"
+        }
+      end
+    end
+
+    class MonthAbbreviation < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "month_abbreviation",
+          partialType: "Month Abbreviation",
+          operationType: "Equality"
+        }
+      end
+    end
+
+    class Month < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "month",
+          partialType: "Month",
+          operationType: "String"
+        }
+      end
+    end
+
+    class Numeric < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "integer",
+          partialType: "Numeric",
+          operationType: "Numeric"
+        }
+      end
+    end
+
+    Integer = Decimal = Numeric
+
+    class Percent < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "currency",
+          partialType: "Currency",
+          operationType: "Numeric"
+        }
+      end
+    end
+
+    class String < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "string",
+          partialType: "Text",
+          operationType: "String"
+        }
+      end
+    end
+
+    class Text < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "text",
+          partialType: "Text",
+          operationType: "String"
+        }
+      end
+    end
+
+    class Uuid < Base
+      def default_options(**_options)
+        {
+          name: name,
+          associationColumnName: attr,
+          columnType: "uuid",
+          partialType: "Uuid",
+          operationType: "Equality"
+        }
+      end
+    end
+
+    class Noop
+      def initialize(...); end
+      def generate(...)
+        {} # Return no options
+      end
+    end
+
+    Array = Json = Noop
+  end
+end