motor-admin 0.1.9

data/lib/motor/build_schema/persist_resource_configs.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module PersistResourceConfigs
+      RESOURCE_ATTRS = %w[display_name visible].freeze
+      COLUMN_ATTRS = %w[name display_name column_type access_type default_value virtual].freeze
+      ASSOCIATION_ATTRS = %w[name display_name visible].freeze
+      ACTION_ATTRS = %w[name display_name action_type preferences visible].freeze
+      TAB_ATTRS = %w[name display_name tab_type preferences visible].freeze
+
+      COLUMN_DEFAULTS = {
+        access_type: 'read_write',
+        default_value: nil,
+        validators: []
+      }.with_indifferent_access
+
+      ACTION_DEFAULTS = {
+        visible: true,
+        preferences: {}
+      }.with_indifferent_access
+
+      TAB_DEFAULTS = {
+        visible: true,
+        preferences: {}
+      }.with_indifferent_access
+
+      module_function
+
+      # @param resource [Motor::Resource]
+      # @return [Motor::Resource]
+      def call(resource)
+        preferences = resource.preferences
+
+        resource = Motor::Resource.find_or_initialize_by(name: resource.name)
+
+        assign_preferences!(resource, preferences)
+
+        resource.save!
+
+        resource
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      # @param resource [Motor::Resource]
+      # @param preferences [HashWithIndifferentAccess]
+      # @return [Motor::Resource]
+      def assign_preferences!(resource, preferences)
+        default_schema = fetch_default_schema(resource.name)
+
+        resource.preferences = normalize_preferences(
+          default_schema,
+          resource.preferences,
+          preferences
+        )
+
+        resource
+      end
+
+      # @param default_prefs [HashWithIndifferentAccess]
+      # @param existing_prefs [HashWithIndifferentAccess]
+      # @param new_prefs [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def normalize_preferences(default_prefs, existing_prefs, new_prefs)
+        normalized_preferences = new_prefs.slice(*RESOURCE_ATTRS).with_indifferent_access
+        normalized_preferences = existing_prefs.merge(normalized_preferences)
+        normalized_preferences = reject_default(default_prefs, normalized_preferences)
+
+        if new_prefs[:columns].present?
+          normalized_preferences[:columns] = normalize_columns(
+            default_prefs[:columns],
+            existing_prefs.fetch(:columns, []),
+            new_prefs.fetch(:columns, [])
+          )
+        end
+
+        if new_prefs[:associations].present?
+          normalized_preferences[:associations] = normalize_associations(
+            default_prefs[:associations],
+            existing_prefs.fetch(:associations, []),
+            new_prefs.fetch(:associations, [])
+          )
+        end
+
+        if new_prefs[:actions].present?
+          normalized_preferences[:actions] = normalize_actions(
+            default_prefs[:actions],
+            existing_prefs.fetch(:actions, []),
+            new_prefs.fetch(:actions, [])
+          )
+        end
+
+        if new_prefs[:tabs].present?
+          normalized_preferences[:tabs] = normalize_tabs(
+            default_prefs[:tabs],
+            existing_prefs.fetch(:tabs, []),
+            new_prefs.fetch(:tabs, [])
+          )
+        end
+
+        normalized_preferences.compact
+      end
+
+      # @param default_columns [Array<HashWithIndifferentAccess>]
+      # @param existing_columns [Array<HashWithIndifferentAccess>]
+      # @param new_columns [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_columns(default_columns, existing_columns, new_columns)
+        (existing_columns.pluck(:name) + new_columns.pluck(:name)).uniq.map do |name|
+          new_column = safe_fetch_by_name(new_columns, name)
+
+          next if new_column[:_remove]
+
+          existing_column = safe_fetch_by_name(existing_columns, name)
+          default_column = safe_fetch_by_name(default_columns, name)
+          column_attrs = new_column.slice(*COLUMN_ATTRS)
+
+          normalized_column = existing_column.merge(column_attrs)
+          normalized_column = reject_default(default_column, normalized_column)
+
+          normalized_column.merge(name: name) if normalized_column.present?
+        end.compact.presence
+      end
+
+      # @param default_actions [Array<HashWithIndifferentAccess>]
+      # @param existing_actions [Array<HashWithIndifferentAccess>]
+      # @param new_actions [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_actions(default_actions, existing_actions, new_actions)
+        (existing_actions.pluck(:name) + new_actions.pluck(:name)).uniq.map do |name|
+          new_action = safe_fetch_by_name(new_actions, name)
+
+          next if new_action[:_remove]
+
+          existing_action = safe_fetch_by_name(existing_actions, name)
+          default_action = safe_fetch_by_name(default_actions, name)
+          action_attrs = new_action.slice(*ACTION_ATTRS)
+
+          normalized_action = existing_action.merge(action_attrs)
+          normalized_action = reject_default(default_action.presence || TAB_DEFAULTS, normalized_action)
+
+          normalized_action.merge(name: name) if normalized_action.present?
+        end.compact.presence
+      end
+
+      # @param default_tabs [Array<HashWithIndifferentAccess>]
+      # @param existing_tabs [Array<HashWithIndifferentAccess>]
+      # @param new_tabs [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_tabs(default_tabs, existing_tabs, new_tabs)
+        (existing_tabs.pluck(:name) + new_tabs.pluck(:name)).uniq.map do |name|
+          new_tab = safe_fetch_by_name(new_tabs, name)
+
+          next if new_tab[:_remove]
+
+          existing_tab = safe_fetch_by_name(existing_tabs, name)
+          default_tab = safe_fetch_by_name(default_tabs, name)
+          tab_attrs = new_tab.slice(*TAB_ATTRS)
+
+          normalized_tab = existing_tab.merge(tab_attrs)
+          normalized_tab = reject_default(default_tab.presence || TAB_DEFAULTS, normalized_tab)
+
+          normalized_tab.merge(name: name) if normalized_tab.present?
+        end.compact.presence
+      end
+
+      # @param default_assocs [Array<HashWithIndifferentAccess>]
+      # @param existing_assocs [Array<HashWithIndifferentAccess>]
+      # @param new_assocs [Array<HashWithIndifferentAccess>]
+      # @return [Array<HashWithIndifferentAccess>]
+      def normalize_associations(default_assocs, existing_assocs, new_assocs)
+        (existing_assocs.pluck(:name) + new_assocs.pluck(:name)).uniq.map do |name|
+          new_assoc = safe_fetch_by_name(new_assocs, name)
+          existing_assoc = safe_fetch_by_name(existing_assocs, name)
+          default_assoc = safe_fetch_by_name(default_assocs, name)
+          assoc_attrs = new_assoc.slice(*ASSOCIATION_ATTRS)
+
+          normalized_assoc = existing_assoc.merge(assoc_attrs)
+          normalized_assoc = reject_default(default_assoc, normalized_assoc)
+
+          normalized_assoc.merge(name: name) if normalized_assoc.present?
+        end.compact.presence
+      end
+
+      def safe_fetch_by_name(list, name)
+        list.find { |e| e[:name] == name } || {}
+      end
+
+      # @param resource_name [String]
+      # @return [HashWithIndifferentAccess]
+      def fetch_default_schema(resource_name)
+        LoadFromRails.build_model_schema(resource_name.classify.constantize)
+      end
+
+      # @param default [HashWithIndifferentAccess]
+      # @param new [HashWithIndifferentAccess]
+      # @return [HashWithIndifferentAccess]
+      def reject_default(default, new)
+        return new unless default
+
+        new.reject do |key, value|
+          default[key].to_json == value.to_json
+        end
+      end
+    end
+  end
+end

data/lib/motor/build_schema/reorder_schema.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Motor
+  module ReorderSchema
+    module_function
+
+    # @param schema [Array<HashWithIndifferentAccess>]
+    # @return [Array<HashWithIndifferentAccess>]
+    def call(schema)
+      configs = load_configs
+
+      schema = sort_by_name(schema, configs['resources.order'])
+
+      schema.map do |model|
+        columns_order = configs["resources.#{model[:name]}.columns.order"]
+        associations_order = configs["resources.#{model[:name]}.associations.order"]
+        actions_order = configs["resources.#{model[:name]}.actions.order"]
+        tabs_order = configs["resources.#{model[:name]}.tabs.order"]
+
+        model.merge(
+          columns: sort_by_name(model[:columns], columns_order, sort_alphabetically: false),
+          associations: sort_by_name(model[:associations], associations_order),
+          actions: sort_by_name(model[:actions], actions_order, sort_alphabetically: false),
+          tabs: sort_by_name(model[:tabs], tabs_order, sort_alphabetically: false)
+        )
+      end
+    end
+
+    # @param list [Array<HashWithIndifferentAccess>]
+    # @param sort_alphabetically [Boolean]
+    # @param order [Array<String>]
+    # @return [Array<HashWithIndifferentAccess>]
+    def sort_by_name(list, order, sort_alphabetically: true)
+      return list if order.blank? && !sort_alphabetically
+
+      list.sort_by do |item|
+        if order.present?
+          order.index(item[:name]) || Float::MAX
+        else
+          item[:display_name]
+        end
+      end
+    end
+
+    # @return [Hash<String, HashWithIndifferentAccess>]
+    def load_configs
+      Motor::Config.all.each_with_object({}) do |config, acc|
+        acc[config.key] = config.value
+      end
+    end
+  end
+end

data/lib/motor/build_schema/utils.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Motor
+  module BuildSchema
+    module Utils
+      module_function
+
+      def slugify(model)
+        model.name.underscore.pluralize.gsub('/', '__')
+      end
+
+      def classify_slug(slug)
+        slug.singularize.gsub('__', '/').classify.constantize
+      end
+    end
+  end
+end

data/lib/motor/dashboards.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative './dashboards/persistance'
+
+module Motor
+  module Dashboards
+  end
+end

data/lib/motor/dashboards/persistance.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Motor
+  module Dashboards
+    module Persistance
+      TitleAlreadyExists = Class.new(StandardError)
+
+      module_function
+
+      def build_from_params(params, current_user = nil)
+        dashboard = assign_attributes(Dashboard.new, params)
+
+        dashboard.author = current_user
+
+        dashboard
+      end
+
+      def create_from_params!(params, current_user = nil)
+        raise TitleAlreadyExists if Dashboard.exists?(['lower(title) = ?', params[:title].to_s.downcase])
+
+        dashboard = build_from_params(params, current_user)
+
+        ApplicationRecord.transaction do
+          dashboard.save!
+        end
+
+        dashboard
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def update_from_params!(dashboard, params)
+        raise TitleAlreadyExists if title_already_exists?(dashboard)
+
+        dashboard = assign_attributes(dashboard, params)
+
+        ApplicationRecord.transaction do
+          dashboard.save!
+        end
+
+        dashboard.tags.reload
+
+        dashboard
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def assign_attributes(dashboard, params)
+        dashboard.assign_attributes(params.slice(:title, :description, :preferences))
+
+        Motor::Tags.assign_tags(dashboard, params[:tags])
+      end
+
+      def title_already_exists?(dashboard)
+        if dashboard.new_record?
+          Dashboard.exists?(['lower(title) = ?', dashboard.title.to_s.downcase])
+        else
+          Dashboard.exists?(['lower(title) = ? AND id != ?', dashboard.title.to_s.downcase, dashboard.id])
+        end
+      end
+    end
+  end
+end

data/lib/motor/forms.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative './forms/persistance'
+
+module Motor
+  module Forms
+  end
+end

data/lib/motor/forms/persistance.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Motor
+  module Forms
+    module Persistance
+      NameAlreadyExists = Class.new(StandardError)
+
+      module_function
+
+      def build_from_params(params, current_user = nil)
+        form = assign_attributes(Form.new, params)
+
+        form.author = current_user
+
+        form
+      end
+
+      def create_from_params!(params, current_user = nil)
+        raise NameAlreadyExists if Form.exists?(['lower(name) = ?', params[:name].to_s.downcase])
+
+        form = build_from_params(params, current_user)
+
+        ApplicationRecord.transaction do
+          form.save!
+        end
+
+        form
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def update_from_params!(form, params)
+        raise NameAlreadyExists if name_already_exists?(form)
+
+        form = assign_attributes(form, params)
+
+        ApplicationRecord.transaction do
+          form.save!
+        end
+
+        form.tags.reload
+
+        form
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def assign_attributes(form, params)
+        form.assign_attributes(params.slice(:name, :description, :api_path, :http_method, :preferences))
+
+        Motor::Tags.assign_tags(form, params[:tags])
+      end
+
+      def name_already_exists?(form)
+        if form.new_record?
+          Form.exists?(['lower(name) = ?', form.name.to_s.downcase])
+        else
+          Form.exists?(['lower(name) = ? AND id != ?', form.name.to_s.downcase, form.id])
+        end
+      end
+    end
+  end
+end

data/lib/motor/hash_serializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Motor
+  class HashSerializer
+    def self.dump(hash)
+      hash.to_json
+    end
+
+    def self.load(hash)
+      return hash unless hash
+
+      hash = JSON.parse(hash.presence || '{}') if hash.is_a?(String)
+
+      if hash.is_a?(Hash)
+        hash.with_indifferent_access
+      else
+        hash || {}
+      end
+    end
+  end
+end