forest_admin_datasource_customizer 1.0.0.pre.beta.21 → 1.0.0.pre.beta.57

data/lib/forest_admin_datasource_customizer/decorators/binary/binary_collection_decorator.rb

@@ -0,0 +1,215 @@
+require 'base64'
+require 'marcel'
+
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Binary
+      class BinaryCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit
+        include ForestAdminDatasourceToolkit::Decorators
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        OPERATORS_WITH_REPLACEMENT = [Operators::AFTER, Operators::BEFORE, Operators::CONTAINS,
+                                      Operators::ENDS_WITH, Operators::EQUAL, Operators::GREATER_THAN,
+                                      Operators::I_CONTAINS, Operators::NOT_IN, Operators::I_ENDS_WITH,
+                                      Operators::I_STARTS_WITH, Operators::LESS_THAN, Operators::NOT_CONTAINS,
+                                      Operators::NOT_EQUAL, Operators::STARTS_WITH, Operators::IN].freeze
+
+        def initialize(child_collection, datasource)
+          super
+          @use_hex_conversion = {}
+        end
+
+        def set_binary_mode(name, type)
+          field = @child_collection.schema[:fields][name]
+
+          raise Exceptions::ForestException, 'Invalid binary mode' unless %w[datauri hex].include?(type)
+
+          unless field&.type == 'Column' && field&.column_type == 'Binary'
+            raise Exceptions::ForestException, 'Expected a binary field'
+          end
+
+          @use_hex_conversion[name] = (type == 'hex')
+          mark_schema_as_dirty
+        end
+
+        def refine_schema(sub_schema)
+          fields = {}
+
+          sub_schema[:fields].each do |name, schema|
+            if schema.type == 'Column'
+              new_schema = schema.dup
+              new_schema.column_type = replace_column_type(schema.column_type)
+              new_schema.validations = replace_validation(name, schema)
+              fields[name] = new_schema
+            else
+              fields[name] = schema
+            end
+          end
+
+          sub_schema[:fields] = fields
+          sub_schema
+        end
+
+        def refine_filter(_caller, filter = nil)
+          filter&.override(
+            condition_tree: filter&.condition_tree&.replace_leafs do |leaf|
+              convert_condition_tree_leaf(leaf)
+            end
+          )
+        end
+
+        def create(caller, data)
+          data_with_binary = convert_record(true, data)
+          record = super(caller, data_with_binary)
+
+          convert_record(false, record)
+        end
+
+        def list(caller, filter, projection)
+          records = super
+          records.map! { |record| convert_record(false, record) }
+
+          records
+        end
+
+        def update(caller, filter, patch)
+          super(caller, filter, convert_record(true, patch))
+        end
+
+        def aggregate(caller, filter, aggregation, limit = nil)
+          rows = super
+          rows.map! do |row|
+            {
+              'value' => row['value'],
+              'group' => row['group'].to_h { |path, value| [path, convert_value(false, path, value)] }
+            }
+          end
+        end
+
+        def convert_condition_tree_leaf(leaf)
+          prefix, suffix = leaf.field.split(':')
+          schema = @child_collection.schema[:fields][prefix]
+
+          if schema.type != 'Column'
+            condition_tree = @datasource.get_collection(schema.foreign_collection).convert_condition_tree_leaf(
+              leaf.override(field: suffix)
+            )
+
+            return condition_tree.nest(prefix)
+          end
+
+          if OPERATORS_WITH_REPLACEMENT.include?(leaf.operator)
+            column_type = if [Operators::IN, Operators::NOT_IN].include?(leaf.operator)
+                            [schema.column_type]
+                          else
+                            schema.column_type
+                          end
+
+            return leaf.override(
+              value: convert_value_helper(true, column_type, should_use_hex(prefix), leaf.value)
+            )
+          end
+
+          leaf
+        end
+
+        def should_use_hex(name)
+          return @use_hex_conversion[name] if @use_hex_conversion.key?(name)
+
+          Utils::Schema.primary_key?(@child_collection, name) || Utils::Schema.foreign_key?(@child_collection, name)
+        end
+
+        def convert_record(to_backend, record)
+          if record
+            record = record.to_h do |path, value|
+              [path, convert_value(to_backend, path, value)]
+            end
+          end
+
+          record
+        end
+
+        def convert_value(to_backend, path, value)
+          prefix, suffix = path.split(':')
+          field = @child_collection.schema[:fields][prefix]
+
+          if field.type != 'Column'
+            foreign_collection = @datasource.get_collection(field.foreign_collection)
+
+            return suffix ? foreign_collection.convert_value(to_backend, suffix,
+                                                             value) : foreign_collection.convert_record(to_backend,
+                                                                                                        value)
+          end
+
+          binary_mode = should_use_hex(path)
+
+          convert_value_helper(to_backend, field.column_type, binary_mode, value)
+        end
+
+        def convert_value_helper(to_backend, column_type, use_hex, value)
+          if value
+            return convert_scalar(to_backend, use_hex, value) if column_type == 'Binary'
+
+            if column_type.is_a? Array
+              return value.map { |v| convert_value_helper(to_backend, column_type[0], use_hex, v) }
+            end
+
+            unless column_type.is_a? String
+              return column_type.to_h { |key, type| [key, convert_value_helper(to_backend, type, use_hex, value[key])] }
+            end
+          end
+
+          value
+        end
+
+        def convert_scalar(to_backend, use_hex, value)
+          if to_backend
+            return use_hex ? BinaryHelper.hex_to_bin(value) : Base64.strict_decode64(value.partition(',')[2])
+          end
+
+          return BinaryHelper.bin_to_hex(value) if use_hex
+
+          data = Base64.strict_encode64(value)
+          mime = Marcel::MimeType.for StringIO.new(value)
+
+          "data:#{mime};base64,#{data}"
+        end
+
+        def replace_column_type(column_type)
+          if column_type.is_a? String
+            return column_type == 'Binary' ? 'String' : column_type
+          end
+
+          return [replace_column_type(column_type[0])] if column_type.is_a? Array
+
+          column_type.transform_values { |type| replace_column_type(type) }
+        end
+
+        def replace_validation(name, column_schema)
+          if column_schema.column_type == 'Binary'
+            validations = []
+            min_length = (column_schema.validations.find { |v| v[:operator] == Operators::LONGER_THAN } || {})[:value]
+            max_length = (column_schema.validations.find { |v| v[:operator] == Operators::SHORTER_THAN } || {})[:value]
+
+            if should_use_hex(name)
+              validations << { operator: Operators::MATCH, value: '/^[0-9a-f]+$/' }
+              validations << { operator: Operators::LONGER_THAN, value: (min_length * 2) + 1 } if min_length
+              validations << { operator: Operators::SHORTER_THAN, value: (max_length * 2) - 1 } if max_length
+            else
+              validations << { operator: Operators::MATCH, value: '/^data:.*;base64,.*/' }
+            end
+
+            if column_schema.validations.find { |v| v[:operator] == Operators::PRESENT }
+              validations << { operator: Operators::PRESENT }
+            end
+
+            return validations
+          end
+
+          column_schema.validations
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/binary/binary_helper.rb

@@ -0,0 +1,17 @@
+require 'base64'
+
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Binary
+      class BinaryHelper
+        def self.bin_to_hex(data)
+          data.unpack1('H*')
+        end
+
+        def self.hex_to_bin(data)
+          data.scan(/../).map(&:hex).pack('c*')
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/chart/chart_collection_decorator.rb

@@ -0,0 +1,41 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Chart
+      class ChartCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit
+        include ForestAdminDatasourceToolkit::Decorators
+
+        attr_reader :charts
+
+        def initialize(child_collection, datasource)
+          @charts = {}
+          super
+        end
+
+        def add_chart(name, &definition)
+          raise(Exceptions::ForestException, "Chart #{name} already exists.") if schema[:charts].include?(name)
+
+          @charts[name] = definition
+          mark_schema_as_dirty
+        end
+
+        def render_chart(caller, name, record_id)
+          if @charts.key?(name)
+            context = ChartContext.new(self, caller, record_id)
+            result_builder = ResultBuilder.new
+
+            return @charts[name].call(context, result_builder)
+          end
+
+          @child_collection.render_chart(caller, name, record_id)
+        end
+
+        def refine_schema(sub_schema)
+          sub_schema[:charts] = sub_schema[:charts].union(@charts.keys)
+
+          sub_schema
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/chart/chart_context.rb

@@ -0,0 +1,33 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Chart
+      class ChartContext < ForestAdminDatasourceCustomizer::Context::CollectionCustomizationContext
+        include ForestAdminDatasourceToolkit
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        attr_reader :composite_record_id
+
+        def initialize(collection, caller, record_id)
+          super(collection, caller)
+          @composite_record_id = record_id
+        end
+
+        def record_id
+          if @composite_record_id.size > 1
+            raise Exceptions::ForestException,
+                  "Collection is using a composite pk: use 'context.composite_record_id'."
+          end
+
+          @composite_record_id[0]
+        end
+
+        def get_record(fields)
+          condition_tree = ConditionTreeFactory.match_ids(@real_collection, [@composite_record_id])
+
+          collection.list(Filter.new(condition_tree: condition_tree), Projection.new(fields))[0]
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/chart/chart_datasource_decorator.rb

@@ -0,0 +1,46 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Chart
+      class ChartDatasourceDecorator < ForestAdminDatasourceToolkit::Decorators::DatasourceDecorator
+        include ForestAdminDatasourceToolkit
+        include ForestAdminDatasourceToolkit::Decorators
+
+        def initialize(child_datasource)
+          @charts = {}
+          super(child_datasource, ChartCollectionDecorator)
+        end
+
+        def schema
+          child_schema = @child_datasource.schema.dup
+
+          duplicate = @charts.keys.find { |name| child_schema[:charts].include?(name) }
+
+          raise(Exceptions::ForestException, "Chart #{duplicate} is defined twice.") if duplicate
+
+          child_schema[:charts] = child_schema[:charts].union(@charts.keys)
+
+          child_schema
+        end
+
+        def add_chart(name, &definition)
+          raise(Exceptions::ForestException, "Chart #{name} already exists.") if schema[:charts].include?(name)
+
+          @charts[name] = definition
+        end
+
+        def render_chart(caller, name)
+          chart_definition = @charts[name]
+
+          if chart_definition
+            return chart_definition.call(
+              Context::AgentCustomizationContext.new(self, caller),
+              ResultBuilder.new
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/chart/result_builder.rb

@@ -0,0 +1,148 @@
+require 'active_support/all'
+
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Chart
+      class ResultBuilder
+        include ForestAdminDatasourceToolkit::Components::Charts
+        include ForestAdminDatasourceToolkit::Utils
+
+        TIME_FORMAT = {
+          Day: '%d/%m/%Y',
+          Week: 'W%V-%G',
+          Month: '%b %y',
+          Year: '%Y'
+        }.freeze
+
+        def value(value, previous_value = nil)
+          ValueChart.new(value, previous_value).serialize
+        end
+
+        def distribution(data)
+          data = HashHelper.convert_keys(data, :to_s).map do |key, value|
+            { key: key, value: value }
+          end
+
+          PieChart.new(data).serialize
+        end
+
+        def percentage(value)
+          PercentageChart.new(value).serialize
+        end
+
+        def objective(value, objective)
+          ObjectiveChart.new(value, objective).serialize
+        end
+
+        def leaderboard(value)
+          data = distribution(value).sort { |a, b| b[:value] - a[:value] }
+
+          LeaderboardChart.new(data).serialize
+        end
+
+        # Add a TimeBasedChart based on a time range and a set of values.
+        # @param time_range - The time range for the chart, specified as "Year", "Month", "Week" or "Day".
+        # @param values - This is an array of objects with 'date' and 'value' properties
+        # @returns {TimeBasedChart} Returns a TimeBasedChart representing the data within the specified
+        # time range.
+        #
+        # @example
+        # time_based(
+        #  'Day',
+        #   [
+        #    { date: '2023-01-01', value: 42 },
+        #    { date: '2023-01-02', value: 55 },
+        #    { date: '2023-01-03', value: null },
+        #   ]
+        # );
+        def time_based(time_range, values)
+          return [] if values.nil?
+
+          values = HashHelper.convert_keys(values, :to_sym)
+          values = values.map { |date, value| { date: date, value: value } } unless values.is_a? Array
+          data = build_time_based_chart_result(time_range, values)
+
+          LineChart.new(data).serialize
+        end
+
+        # Add a MultipleTimeBasedChart based on a time range,
+        # an array of dates, and multiple lines of data.
+        #
+        # @param time_range - The time range for the chart, specified as "Year", "Month", "Week" or "Day".
+        # @param dates - An array of dates that define the x-axis values for the chart.
+        # @param lines - An array of lines, each containing a label and an array of numeric data values (or null)
+        # corresponding to the dates.
+        # @returns {MultipleTimeBasedChart} Returns a MultipleTimeBasedChart representing multiple
+        # lines of data within the specified time range.
+        #
+        # @example
+        # multiple_time_based(
+        #  'Day',
+        #  [
+        #    Date.new('1985-10-26'),
+        #    Date.new('2011-10-05T14:48:00.000Z'),
+        #    Date.new()
+        #  ],
+        #  [
+        #    { label: 'line1', values: [1, 2, 3] },
+        #    { label: 'line2', values: [3, 4, null] }
+        #  ],
+        # );
+        def multiple_time_based(time_range, dates, lines)
+          return { labels: nil, values: nil } if dates.nil? || lines.nil?
+
+          formatted_times = nil
+          formatted_lines = lines.map do |line|
+            values = dates.each_with_index.with_object([]) do |(date, index), memo|
+              memo.push({ date: date, value: line[:values][index] })
+            end
+
+            build_time_based = build_time_based_chart_result(time_range, values)
+            formatted_times = build_time_based.map { |time_based| time_based[:label] } if formatted_times.nil?
+
+            { key: line[:label], values: build_time_based.map { |time_based| time_based[:values][:value] } }
+          end
+
+          {
+            labels: formatted_times,
+            values: formatted_times&.length&.positive? ? formatted_lines : nil
+          }
+        end
+
+        def smart(data)
+          data
+        end
+
+        private
+
+        def build_time_based_chart_result(time_range, points)
+          return [] if points.empty?
+
+          format = TIME_FORMAT[time_range.to_sym]
+          formatted = {}
+          points.each do |point|
+            point[:date] = DateTime.parse(point[:date].to_s) if point[:date].is_a?(String) || point[:date].is_a?(Symbol)
+            label = point[:date].strftime(format)
+            formatted[label] = (formatted[label] || 0) + point[:value] if point[:value].is_a? Numeric
+          end
+
+          data_points = []
+          dates = points.map { |point| point[:date] }
+                        .sort { |date_a, date_b| date_a - date_b }
+
+          # first date
+          current = dates.first.send(:"beginning_of_#{time_range.to_s.downcase}")
+          last = dates.last
+
+          while current <= last
+            label = current.strftime(format)
+            data_points << { label: label, values: { value: formatted[label] || 0 } }
+            current += 1.send(time_range.to_s.downcase.to_sym)
+          end
+
+          data_points
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/computed/compute_collection_decorator.rb

@@ -0,0 +1,115 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Computed
+      class ComputeCollectionDecorator < ForestAdminDatasourceToolkit::Decorators::CollectionDecorator
+        include ForestAdminDatasourceToolkit::Components::Query
+        include ForestAdminDatasourceToolkit::Validations
+        include ForestAdminDatasourceCustomizer::Decorators::Computed::Utils
+        include ForestAdminDatasourceToolkit::Exceptions
+
+        def initialize(child_collection, datasource)
+          super
+          @computeds = {}
+        end
+
+        def get_computed(path)
+          index = path.index(':')
+          return @computeds[path] if index.nil?
+
+          foreign_collection = schema[:fields][path[0, index]].foreign_collection
+          association = @datasource.get_collection(foreign_collection)
+
+          association.get_computed(path[index + 1, path.length - index - 1])
+        end
+
+        def register_computed(name, computed)
+          FieldValidator.validate_name(@name, name)
+
+          # Check that all dependencies exist and are columns
+          computed.dependencies.each do |field|
+            FieldValidator.validate(self, field)
+          end
+
+          if computed.dependencies.length <= 0
+            raise ForestException,
+                  "Computed field '#{name}' must have at least one dependency."
+          end
+
+          @computeds[name] = computed
+          mark_schema_as_dirty
+        end
+
+        def list(caller, filter, projection)
+          child_projection = projection.replace { |path| rewrite_field(self, path) }
+          records = @child_collection.list(caller, filter, child_projection)
+          return records if child_projection.equals(projection)
+
+          context = ForestAdminDatasourceCustomizer::Context::CollectionCustomizationContext.new(self, caller)
+
+          ComputedField.compute_from_records(context, self, child_projection, projection, records)
+        end
+
+        def aggregate(caller, filter, aggregation, limit = nil)
+          # No computed are used in the aggregation => just delegate to the underlying collection.
+          unless aggregation.projection.any? do |field|
+                   get_computed(field)
+                 end
+            return @child_collection.aggregate(caller, filter, aggregation,
+                                               limit)
+          end
+
+          # Fallback to full emulation.
+          aggregation.apply(
+            list(caller, filter, aggregation.projection),
+            caller.timezone,
+            limit
+          )
+        end
+
+        def refine_schema(child_schema)
+          schema = child_schema.clone
+          schema[:fields] = child_schema[:fields].clone
+
+          @computeds.each do |name, computed|
+            schema[:fields][name] = ForestAdminDatasourceToolkit::Schema::ColumnSchema.new(
+              column_type: computed.column_type,
+              default_value: computed.default_value,
+              enum_values: computed.enum_values || [],
+              filter_operators: [],
+              is_primary_key: false,
+              is_read_only: true,
+              is_sortable: false
+            )
+          end
+
+          schema
+        end
+
+        def rewrite_field(collection, path)
+          # Projection is targeting a field on another collection => recurse.
+          if path.include?(':')
+            prefix = path.split(':')[0]
+            schema = collection.schema[:fields][prefix]
+            association = collection.datasource.get_collection(schema.foreign_collection)
+
+            return Projection.new([path])
+                             .unnest
+                             .replace { |sub_path| rewrite_field(association, sub_path) }
+                             .nest(prefix: prefix)
+          end
+
+          # Computed field that we own: recursively replace by dependencies
+          computed = collection.get_computed(path)
+
+          if computed
+            Projection.new(computed.dependencies.flatten).replace do |dep_path|
+              rewrite_field(collection, dep_path)
+            end
+          else
+            Projection.new([path])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_customizer/decorators/computed/computed_definition.rb

@@ -0,0 +1,21 @@
+module ForestAdminDatasourceCustomizer
+  module Decorators
+    module Computed
+      class ComputedDefinition
+        attr_reader :column_type, :dependencies, :default_value, :enum_values
+
+        def initialize(column_type:, dependencies:, values:, default_value: nil, enum_values: nil)
+          @column_type = column_type
+          @dependencies = dependencies
+          @values = values
+          @default_value = default_value
+          @enum_values = enum_values
+        end
+
+        def get_values(*args)
+          @values.call(*args)
+        end
+      end
+    end
+  end
+end