action_blocks 0.1.0

data/lib/action_blocks/builders/summary_field_aggregation_functions.rb

@@ -0,0 +1,41 @@
+module ActionBlocks
+  module SummaryFieldAggregationFunctions
+    def count
+      # mk = @parent_reference.related_model_key.clone
+      # mk["model-"]=''
+      # field_key = "field-#{mk}-#{id}"
+      # field_builder = ActionBlocks.find(field_key)
+
+      return {
+        path: [:id],
+        function: ->(*args) { count(*args) }\
+      }
+    end
+
+    def concat(field, delimiter)
+      mk = @parent_reference.related_model_key.clone
+      mk["model-"]=''
+      field_key = "field-#{mk}-#{field}"
+      puts field_key
+      field_builder = ActionBlocks.find(field_key)
+
+      return {
+        path: field_builder.select_requirements[:path],
+        function: ->(*args) { string_agg(delimiter, *args) }
+      }
+    end
+
+    def every(field, predicate, value)
+      mk = @parent_reference.related_model_key.clone
+      mk["model-"]=''
+      field_key = "field-#{mk}-#{field}"
+      puts field_key
+      field_builder = ActionBlocks.find(field_key)
+
+      return {
+      path: field_builder.select_requirements[:path],
+      function: ->(*args) { every(predicate, value, *args) }
+      }
+    end
+  end
+end

data/lib/action_blocks/builders/table_builder.rb

@@ -0,0 +1,259 @@
+module ActionBlocks
+  class TableBuilder < ActionBlocks::BlockType
+    attr_accessor :workspace, :subspace, :dashboard
+    block_type :table
+    sets :title
+    sets :scope
+    sets :view
+    sets :columns
+    references :model
+    references :selection_model
+    references :selection, handler: -> (builder, model, selection) {
+      builder.selection_model_key = "model-#{model}"
+      builder.selection_key = "selection-#{model}-#{selection}"
+    }
+
+    builds_many :table_columns, :col, 'ActionBlocks::TableColumnBuilder'
+
+    validates :columns, presence: true
+    validates :model_key, presence: true
+
+    validate :scope, :validate_scope
+    def validate_scope
+      return unless scope
+      errors.add(:scope, 'requires Proc -> () {}') if scope.class != Proc
+      if scope && scope.class == Proc
+        valid_parameters = [%i[keyreq current_user]]
+        valid_parameters << [:keyreq, dashboard.model.id.to_sym] if dashboard.model
+        valid_parameters << [:keyreq, subspace.model.id.to_sym] if subspace.model
+        invalid_parameters = scope.parameters - valid_parameters
+        errors.add(:scope, "has invalid parameter: #{invalid_parameters}  Allowed: #{valid_parameters}") unless invalid_parameters.empty?
+      end
+    end
+
+    validate :scope, :validate_selection_model
+    def validate_selection_model
+      if dashboard.model != selection_model && subspace.model != selection_model
+        errors.add(:selection_model, "selection model not in subspace or dashboard")
+      end
+    end
+
+    def before_build(parent, *args)
+      @dashboard = parent
+      @subspace = @dashboard.subspace
+      @workspace = @subspace.workspace
+      @title = id.to_s.titleize
+      @id = args[0]
+    end
+
+    # Create a field reference for each column
+    def after_build(_parent, *_args)
+      (@columns || []).each do |c|
+        @dsl_delegate.col(c)
+      end
+    end
+
+    def key
+      "table-#{workspace.id}_#{subspace.id}_#{dashboard.id}_#{@id}"
+    end
+
+    def allowed_columns(_user)
+      model_associations = model.active_model.reflect_on_all_associations(:belongs_to)
+      model_association_columns = model_associations.map { |ma| ma.name.to_s + '_id' }
+      columns = [:id] + @columns + model_association_columns
+      columns.uniq
+    end
+
+    def select_fields()
+      [
+        data_select_fields,
+        view_link_select_fields
+      ].flatten
+    end
+
+    def selection_match_requirements(user)
+      if selection
+        selection.match_reqs(user)
+      else
+        []
+      end
+    end
+
+    def filter_requirements(user:, record:)
+      filter_reqs = []
+      if selection && record
+        filter_reqs << selection.record_filter_reqs(user: user, record: record)
+      end
+      return filter_reqs.flatten
+    end
+
+    # Reason to move logic to model
+    # would be to centralize user level
+    # access to columns
+
+    def data_select_fields
+      @table_columns.map(&:field)
+    end
+
+    # Technical debt deep discovery
+    # e.g. Subspace model being case
+    #      and this model being change order
+
+    def view_link_select_fields
+      # Find dashboards in modeled subspace
+      @workspace.subspaces.each do |ss|
+        next unless ss.model && ss.model.id != model.id
+        ss.dashboards.each do |d|
+          next unless d.model && d.model.id == model.id
+          ref_f = model.fields.find do |f|
+            f.field_type == 'reference' &&
+              f.id == model.id &&
+              f.model.id == ss.model.id
+          end || model.fields.find do |f|
+            f.field_type == 'reference' &&
+              f.model.id == ss.model.id
+          end
+          return [
+            model.fields_hash[:id],
+            model.fields_hash[ref_f.relation.join_foreign_key.to_sym]
+          ].flatten
+        end
+      end
+      [
+        model.fields_hash[:id]
+      ]
+    end
+
+    def hashify(_user)
+      {
+        title: @title,
+        key: key,
+        type: type,
+        column_keys: allowed_columns(nil),
+        view: @view,
+        model_key: model.key,
+        table_columns: @table_columns.map(&:hashify)
+      }
+    end
+
+    # Given params subspace_model_id and/or workspace_model_id
+    # Find records and create named arguments
+    # If subspace_model_id was 4 and this table was in a subspace belonging to Work Order
+    # arguments would be { work_order: WorkOrder.find(4) }
+    def scope_args(params:, user:)
+      if scope
+        subspace_variable_name = subspace.model.try(:id).try(:to_sym) # returns a label such as :work_order
+        dashboard_variable_name = dashboard.model.try(:id).try(:to_sym) # returns a label such as :work_order
+        args = {}
+        if subspace_variable_name && scope.parameters.include?([:keyreq, subspace_variable_name])
+          subspace_record = subspace.model.active_model.find(params[:subspace_model_id])
+          # Todo: check user has read access to subspace record
+          args[subspace_variable_name] = subspace_record
+        end
+        if dashboard_variable_name && scope.parameters.include?([:keyreq, dashboard_variable_name])
+          dashboard_record = dashboard.model.active_model.find(params[:dashboard_model_id])
+          # Todo: check user has read access to dashboard_record
+          args[dashboard_variable_name] = dashboard_record
+        end
+        if scope.parameters.include?([:keyreq, :current_user])
+          args[:current_user] = user
+        end
+        args
+      else
+        {}
+      end
+    end
+
+    # Given params subspace_model_id and/or workspace_model_id
+    # Get the parent selection record
+    def selection_record(params:, user: nil)
+      if selection
+        subspace_model_name = subspace.model.try(:id).try(:to_sym) # returns a label such as :work_order
+        dashboard_model_name = dashboard.model.try(:id).try(:to_sym) # returns a label such as :work_order
+        selection_model_name = selection.base_model.try(:id).try(:to_sym)
+
+        if !subspace_model_name.blank? && selection_model_name == subspace_model_name
+          record = subspace.model.active_model.find(params[:subspace_model_id])
+        end
+        if !dashboard_model_name.blank? && selection_model_name == dashboard_model_name
+          record = dashboard.model.active_model.find(params[:dashboard_model_id])
+        end
+        if dashboard_model_name == subspace_model_name
+          raise "Ambiguous model nesting.  ActionBlock validation should have prevented this."
+        end
+        if dashboard_model_name != selection_model_name && subspace_model_name != selection_model_name
+          raise "Invalid selection model.  ActionBlock validation should have prevented this."
+        end
+        record
+      else
+        nil
+      end
+    end
+
+    def to_json(params:, user:)
+      if scope
+        scope_to_json(params: params, user: user)
+      else
+        pp({
+          params: params,
+          user: user
+        })
+        builder_to_json(params: params, user: user)
+      end
+    end
+
+    # Legacy Support
+    def scope_to_json(params:, user:)
+      if scope.parameters.length > 0
+        s = scope.call(scope_args(params: params, user: user))
+      else
+        s = scope.call()
+      end
+      return s.to_json
+    end
+
+    def builder_engine(params:, user:)
+      klass = model.active_model
+      selection_match_reqs = selection_match_requirements(user)
+      record = selection_record(params: params, user: user)
+      filter_reqs = filter_requirements(user: user, record: record)
+
+      # pp({
+      #   record: record,
+      #   select_fields: select_fields,
+      #   selection_match_reqs: selection_match_reqs,
+      #   filter_reqs: filter_reqs
+      # })
+
+      data_engine = ActionBlocks::DataEngine.new(klass,
+        select_fields: select_fields,
+        selection_match_reqs: selection_match_reqs,
+        selection_filter_reqs: filter_reqs
+      )
+      data_engine
+    end
+
+    def builder_to_json(params:, user:)
+      engine = builder_engine(params: params, user: user)
+      return engine.to_json
+    end
+
+
+  end
+
+  class TableColumnBuilder < ActionBlocks::BaseBuilder
+    references :field
+    def before_build(parent, *args)
+      @id = args[0]
+      pm = parent.model_key.dup
+      pm['model-'] = ''
+      @field_key = "field-#{pm}-#{@id}"
+    end
+
+    def hashify
+      {
+        field_key: @field_key
+      }
+    end
+  end
+end

data/lib/action_blocks/builders/workspace_builder.rb

@@ -0,0 +1,282 @@
+module ActionBlocks
+
+  class WorkspaceBuilder < ActionBlocks::BlockType
+    block_type :workspace
+    sets :title
+    builds_many :subspaces, :subspace, 'ActionBlocks::SubspaceBuilder'
+    # builds_many :record_paths, :record_path, 'ActionBlocks::RecordPathBuilder'
+
+    validate :one_route_per_model
+    validate :one_non_model_subspace_per_category
+
+    def one_non_model_subspace_per_category
+      subspace_categories.each do |sc|
+        if @subspaces.
+          select {|ss| ss.category == sc && ss.model_key.nil? }.count > 1
+          errors.add(:subspaces, "Subspace category #{sc.to_s} has more than one non-modeled subspace")
+        end
+      end
+    end
+
+    def one_route_per_model
+      models = subspaces.map {|ss| ss.model_key}.compact
+      subspaces.each do |ss|
+        models += ss.dashboards.map {|ss| ss.model_key}.compact
+      end
+      models.uniq.each do |model|
+        if models.select {|m| model == m}.count > 1
+          errors.add(:subspaces, "More than one subspace or dashboard uses model #{model}")
+        end
+      end
+    end
+
+    def before_build(parent, *args)
+      @title = args[0].to_s.titleize
+    end
+
+    def subspace_categories
+      @subspaces.map(&:category).uniq
+    end
+
+    def model_paths
+      subspace_paths.merge(dashboard_paths)
+    end
+
+    def subspace_paths
+      paths = {}
+      @subspaces.each do |ss|
+        if ss.model_key
+          paths[ss.model_key] = {
+            path_type: :subspace,
+            subspace_category: ss.category,
+            subspace_model: ss.model_key,
+            subspace_key: ss.key
+          }
+        end
+      end
+      return paths
+    end
+
+    def dashboard_paths
+      paths = {}
+      @subspaces.each do |ss|
+        if ss.model_key
+          ss.dashboards.each do |ds|
+            paths[ds.model_key] = {
+              path_type: :dashboard,
+              subspace_category: ss.category,
+              subspace_model: ss.model_key,
+              subspace_key: ss.key,
+              dashboard_category: ds.category,
+              dashboard_model: ds.model_key,
+              dashboard_key: ds.key
+            }
+          end
+        end
+      end
+      return paths
+    end
+
+    def hashify_subspace_categories(user)
+      isFirst = true
+      results = []
+      subspace_categories.each do |category|
+        results << {
+          first: isFirst,
+          type: 'subspace_category',
+          category: category,
+          title: category.to_s.titleize,
+          subspaces: @subspaces.
+            select {|ss| ss.category == category}.
+            map { |ss| ss.hashify(user) },
+        }
+        isFirst = false
+      end
+      return results
+    end
+
+    def hashify(user)
+      {
+        # key: key,
+        title: @title,
+        id: @id,
+        subspaces: @subspaces.map { |ss| ss.hashify(user) },
+        subspace_categories: hashify_subspace_categories(user),
+        model_paths: model_paths
+        # record_paths: @record_paths.map { |rp| rp.hashify(user) }
+      }
+    end
+  end
+
+  # class RecordPathBuilder < ActionBlocks::BaseBuilder
+  #   sets :model # currently used by table to find this
+  #
+  #   sets :subspace # What path/url to share to control active navigation
+  #   sets :recordspace # What recordspace to render
+  #   sets :dashboard # What path/url of the recordspace dashboard to control active navigation
+  #   sets :recordboard # What recordboard to render
+  #
+  #   def before_build(parent, *args)
+  #     # When Creating Links for Records of type @model
+  #     @model = args[0]
+  #     # Create Links with this information
+  #     @subspace = args[1]
+  #     @recordspace = args[2]
+  #     @dashboard = args[3]
+  #     @recordboard = args[4]
+  #   end
+  #
+  #   def hashify(user)
+  #     {
+  #       model: @model,
+  #       subspace: @subspace,
+  #       dashboard: @dashboard,
+  #       recordspace: @recordspace,
+  #       recordboard: @recordboard
+  #     }
+  #   end
+  # end
+
+  class SubspaceBuilder < ActionBlocks::BaseBuilder
+    attr_accessor :workspace
+    sets :title
+    sets :category
+    references :model
+    builds_many :dashboards, :dashboard, 'ActionBlocks::DashboardBuilder'
+    sets_many :recordspace_keys, :mounts
+
+    validates :category, presence: true
+
+    def key
+      "subspace-#{@id}".to_sym
+    end
+
+    def before_build(parent, *args)
+      @workspace = parent
+      @title = args[0].to_s.titleize
+      @category = args[0]
+      if args[1]
+        @model_key = "model-#{args[1]}"
+      end
+    end
+
+    def dashboard_categories
+      @dashboards.map(&:category).uniq
+    end
+
+    def hashify_dashboard_categories(user)
+      isFirst = true
+      results = []
+      dashboard_categories.each do |category|
+        results << {
+          first: isFirst,
+          type: 'dashboard_categories',
+          category: category,
+          title: category.to_s.titleize,
+          dashboards: @dashboards.
+            select {|d| d.category == category}.
+            map { |d| d.hashify(user) },
+        }
+        isFirst = false
+      end
+      return results
+    end
+
+
+    def hashify(user)
+      {
+        key: key,
+        title: @title,
+        category: @category,
+        model: @model_key,
+        dashboards: @dashboards.map{ |db| db.hashify(user) },
+        dashboard_categories: hashify_dashboard_categories(user),
+        recordspace_keys: @recordspace_keys
+      }
+    end
+  end
+
+  class DashboardBuilder < ActionBlocks::BaseBuilder
+    attr_accessor :workspace, :subspace
+    sets :title
+    sets :category
+    references :model
+    builds_many :dashlets, :table, 'ActionBlocks::TableBuilder'
+    builds_many :dashlets, :barchart, 'ActionBlocks::BarchartBuilder'
+    builds_many :dashlets, :mount_form, 'ActionBlocks::MountedFormBuilder'
+
+    def before_build(parent, *args)
+      @subspace = parent
+      @workspace = @subspace.workspace
+      @category = args[0]
+      @title = @category.to_s.titleize
+      if args[1]
+        @model_key = "model-#{args[1]}"
+      end
+    end
+
+    validates :category, presence: true
+    validate :has_unique_dashlets
+    def has_unique_dashlets
+      @dashlets.group_by(&:key).each do |k, dashlets|
+          if(dashlets.length > 1)
+            d = dashlets.first
+            errors.add(:dashlets, "Duplicate #{d.type.inspect} added to dashboard #{workspace.id}/#{subspace.id}/#{id} with id #{d.id.inspect}")
+          end
+      end
+    end
+
+    def hashify(user)
+      {
+        key: key,
+        title: @title,
+        model: @model_key,
+        category: @category,
+        dashlet_keys: @dashlets.map(&:key)
+      }
+    end
+  end
+
+  class MountedFormBuilder < ActionBlocks::BlockType
+    block_type :mounted_form
+    references :form
+
+    def before_build(parent, *args)
+      @id = args[0]
+      @dashboard = parent
+      @subspace = @dashboard.subspace
+      @form_key = "form-#{@id}"
+    end
+
+    # validate :validate_mounted_to
+    # def validate_mounted_to
+    #   return unless [:dashboard, :subspace].include?(@mounted_to)
+    #   errors.add(:mounted_to, "#{@parent.key} #{type} must be mounted to :dashboard or :subspace but #{@mounted_to.inspect} was specified.")
+    # end
+    #
+    # validate :validate_mount_point_matches_model
+    # def validate_mount_point_matches_model
+    #   # TODO
+    # end
+
+    def after_load
+      # After load is called after all blocks are in the store
+      if form.model.id == @subspace.model.try(:id)
+        @mounted_to = :subspace
+      end
+      if form.model.id == @dashboard.model.try(:id)
+        @mounted_to = :dashboard
+      end
+    end
+
+    def hashify(user)
+      {
+        type: :mounted_form,
+        form_key: @form_key,
+        mounted_to: @mounted_to
+      }
+    end
+  end
+
+
+end