underworld 1.0.0

data/lib/underworld/dashboard/models.rb

@@ -0,0 +1,2 @@
+module Underworld::Dashboard::Models
+end

data/lib/underworld/dashboard/models/sidebar.rb

@@ -0,0 +1,139 @@
+module Underworld::Dashboard::Models
+  class Item
+
+    attr_reader :title, :url, :icon, :model, :members_only
+    def initialize(title, options)
+      @title = title
+      @model = nil
+      extract_options(options)
+    end
+
+    def visible?(user)
+      return true if @model.nil?
+
+      if @model.respond_to? :map
+        permissions = @model.map do |model|
+          # Find the appropriate policy for each model
+          # and authorize the user against that.
+          Pundit.policy!(user, model.to_sym).index?
+        end
+        # If user don't have access to none of the models
+        # then the menu should not be visible
+        permissions.any?
+      else
+
+        # Authorize the menu visibility against user and given model
+        Pundit.policy!(user, @model.to_sym).index?
+      end
+    end
+
+    private
+    def extract_options(options)
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+  end
+
+  class Menu < Item
+    def children
+      @children || []
+    end
+
+    def add_child(child)
+      @children ||= []
+      @children << child
+    end
+
+    def initialize(title, options)
+      children = options.delete :children
+      if children
+        @children = children.map do |child|
+          Item.new(child.delete(:title), child)
+        end
+      end
+      super
+    end
+  end
+
+  class RootMenu < Array
+    alias :add_child :<<
+  end
+
+  class Sidebar
+
+    include ActionView::Helpers::TranslationHelper
+
+    def initialize(title, **options)
+      @title = title
+      extract_options(options)
+      @tree = RootMenu.new
+      @current_node = @tree
+    end
+
+    def children
+      @tree
+    end
+
+    def title
+      @title || I18n.t('underworld.dashboard.sidebar.title')
+    end
+
+    def menu(name, **options, &block)
+      item = Menu.new(name, options)
+
+
+      @current_node.add_child item
+
+      prev_node = @current_node
+      @current_node = item
+
+      block.call if block_given?
+
+      @current_node = prev_node
+    end
+
+    def item(name, **options)
+      item = Item.new(name, options)
+      @current_node.add_child item
+    end
+
+    def underworld_entries
+      menu(t('underworld.dashboard.user_management'),
+        icon: 'fa fa-users',
+        model: 'Underworld::User') do
+        item(I18n.t('underworld.dashboard.users'),
+          model: 'Underworld::User',
+          url: Underworld::Engine.routes.url_helpers.dashboard_auth_users_path)
+
+        item(I18n.t('underworld.dashboard.groups'),
+          model: 'Underworld::Group',
+          url: Underworld::Engine.routes.url_helpers.dashboard_auth_groups_path)
+
+      end
+
+      menu(t('underworld.dashboard.user_message'),
+        icon: 'fa fa-envelope-o',
+        model: 'Underworld::UserMessage') do
+
+        item(I18n.t('underworld.dashboard.user_messages.inbox'),
+          model: 'Underworld::UserMessage',
+          url: Underworld::Engine.routes.url_helpers.dashboard_user_messages_path)
+        item(I18n.t('underworld.dashboard.user_messages.sent'),
+          model: 'Underworld::UserMessage',
+          url: Underworld::Engine.routes.url_helpers.dashboard_user_messages_path)
+        item(I18n.t('underworld.dashboard.user_messages.draft'),
+          model: 'Underworld::UserMessage',
+          url: Underworld::Engine.routes.url_helpers.dashboard_user_messages_path)
+
+      end
+    end
+
+    private
+    def extract_options(options)
+      @icon  = options.delete(:icon)
+      @id    = options.delete(:id)
+      @class = options.delete(:class)
+    end
+  end
+end

data/lib/underworld/dashboard/sections.rb

@@ -0,0 +1,2 @@
+module Underworld::Dashboard::Sections
+end

data/lib/underworld/dashboard/sections/resource.rb

@@ -0,0 +1,229 @@
+module Underworld::Dashboard::Sections
+  # This module contains several helpers method which would
+  # be useful for the rest of underworld dashboard operation.
+  module Resource
+
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.before_action :setup_named_routes
+    end
+
+    def _resource_title
+      controller_name.humanize
+    end
+
+    protected
+
+    def _resources
+      instance_variable_get("@{plural_name")
+    end
+
+    def plural_name
+      controller_name.underscore
+    end
+
+    def model_name
+      "::#{controller_path.gsub('dashboard/', '').classify}"
+    end
+
+    def model
+      model_name.constantize
+    rescue
+      msg = "Can't find model '#{model_name}'. Please override 'model' method in your dashboard controller."
+      fail NameError, msg
+    end
+
+    def _namespace
+      pieces = controller_path.gsub('dashboard/', '').split('/')
+      return '' if pieces.length == 1
+
+      pieces.pop
+      pieces.join('/')
+    end
+
+    def _route_engine
+      if _namespace.empty?
+        Rails.application
+      else
+        engine = "#{_namespace.split('/')[0]}::Engine".classify
+        if Object.const_defined? engine
+          engine.constantize
+        else
+          logger.info 'You are using locale modules please define route_engine in your controller'
+          Rails.application
+        end
+      end
+    end
+
+    # Return the array of action buttons in given `property_object`.
+    # `property_object` is an instance of once of DSL classes.
+    def action_buttons(property_object)
+      @_action_buttons = property_object.action_buttons || []
+    end
+
+    def _engine
+      nil
+    end
+
+    private
+
+    def _route_name
+      nil
+    end
+
+    def attachment_fields
+      if model.respond_to? :attachment_definitions
+        return model.attachment_definitions.keys
+      end
+
+      []
+    end
+
+    def has_attachment?
+      !attachment_fields.empty?
+    end
+
+    def _index_route
+      if respond_to? :index
+        url_for(controller: params[:controller],
+                action: :index)
+      end
+    end
+
+    def _show_route(id)
+      if respond_to? :show
+        url_for(controller: params[:controller],
+                action: :show,
+                id: id)
+      end
+    end
+
+    def _edit_route(id)
+      if respond_to? :edit
+        url_for(controller: params[:controller],
+                action: :edit,
+                id: id)
+      end
+    end
+
+    def _new_route
+      if respond_to? :new
+        url_for(controller: params[:controller], action: :new)
+      end
+    end
+
+    def setup_named_routes
+      @engine        = _engine || _route_engine
+      @index_route   = method(:_index_route)
+      @new_route     = method(:_new_route)
+      @show_route    = method(:_show_route)
+      @edit_route    = method(:_edit_route)
+    end
+
+    def successful_response(section, msg = nil)
+      @_msg = msg
+
+      respond_to do |f|
+        if _override_views.include? section.to_sym
+          f.js
+          f.html
+        else
+          flash[:success] = msg
+
+          f.js { render "underworld/dashboard/resource/#{section}" }
+          f.html { redirect_to _index_route }
+        end
+      end
+    end
+
+    def errorful_resopnse(section, msg = nil, &block)
+      @_msg = msg
+
+      respond_to do |f|
+        if _override_views.include? section.to_sym
+          f.js { render :errors }
+          f.html { render :errors }
+        else
+          flash[:error] = msg
+
+          f.js { render 'underworld/dashboard/shared/errors' }
+          if block_given?
+            f.html(&block)
+          else
+            f.html { redirect_to _index_route }
+          end
+        end
+      end
+    end
+
+    # TODO: Move this method to a suitable place
+    def symbolify_keys(hash)
+      hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+    # The actual DSL for resource ages
+    module ClassMethods
+      # Via this method user can specify the engine or application name
+      # which current resource is defined under. Default value is:
+      # Rails.application
+      def route_engine(name = nil, &block)
+        define_method(:_route_engine) do
+          return block.call if block_given?
+          return name unless name.nil?
+          fail 'You have to provide a name or a block'
+        end
+      end
+
+      # Via this method user can specify the name of current resource
+      # scope, Default value is `dashboard`
+      def route_scope(name, &block)
+        define_method(:_route_scope) do
+          return block.call if block_given?
+          name
+        end
+      end
+
+      # Using this method user can override the route namespace guessed by
+      # Underworld.
+      def route_namespace(name, &block)
+        define_method(:_namespace) do
+          return block.call if block_given?
+          name
+        end
+      end
+      # Set the engine name of current controller. It's necessary to provide and
+      # engine name if the controller belongs to an engine other than Underworld or
+      # Rails.application.
+      def engine(name)
+        define_method(:_engine) do
+          name.constantize
+        end
+      end
+
+      # Specify the model name of controller. This method overrides the
+      # `model_class` **class method** and `model_name` instance method.
+      def model_name(name)
+        define_singleton_method :model_class do
+          name.constantize
+        end
+
+        define_method :model_name do
+          name
+        end
+      end
+
+      # Returns the actual model class by looking at `controller_name` and
+      # and `controller_path`. If user uses the `model_name` **class method**
+      # (the `model_name` DSL) then this method will override by the
+      # `model_name` defination of `model_class`
+      def model_class
+        name  = controller_name
+        path  = controller_path.gsub(name, '').gsub(/dashboard\//, '')
+
+        "#{path}#{name}".classify.constantize
+      end
+    end
+
+  end
+end

data/lib/underworld/dashboard/sections/resource_create.rb

@@ -0,0 +1,263 @@
+require 'set'
+require_dependency 'underworld/dashboard/dsl/create'
+
+module Underworld::Dashboard::Sections
+  module ResourceCreate
+
+    extend ActiveSupport::Concern
+
+    # The actual action method of a dashboard controller
+    def new
+      authorize model, :create?
+
+      collect_model_fields_for_form
+
+      @resource           = model.new
+      @resource_title     = t(_resource_title.singularize)
+      @_fields_properties = form_properties._field_details
+      @multipart          = has_attachment?
+
+      new_hook(@resource)
+      return if _override_views.include? :new
+      render 'underworld/dashboard/resource/new'
+    end
+
+    def edit
+      # TODO: Handle nested resource in here
+      @resource = model.find(params[:id])
+      authorize @resource, :update?
+
+      collect_model_fields_for_form
+
+      @resource_title     = t(_resource_title.singularize)
+      @_fields_properties = form_properties._field_details
+      @multipart          = has_attachment?
+
+      edit_hook(@resource)
+
+      return if _override_views.include? :edit
+      render 'underworld/dashboard/resource/edit'
+    end
+
+    def update
+      # TODO: Handle nested resource in here
+      @resource = model.find(params[:id])
+      authorize @resource
+
+      new_params = creation_params
+      new_params.merge(reflections_hash) if reflections_hash
+
+      # Customize update behaviour before updating resource
+      before_update_hook(@resource)
+
+      # TODO: Move this method to a suitable place instead of controller
+      #       itself
+      new_params = symbolify_keys(new_params)
+
+      @resource.assign_attributes(**new_params)
+
+      if @resource.save
+        # Customize update behaviour after updating resource
+        after_update_hook(@resource)
+        successful_response(:update)
+      else
+        errorful_resopnse(:update, @resource.errors) do
+          redirect_to :edit
+        end
+      end
+    end
+
+    # The actual action method for creating new resource.
+    def create
+      authorize model
+
+      @resource = model.new(creation_params)
+      @resource.assign_attributes(**reflections_hash) unless reflections_hash.nil?
+
+      # Customize the create behaviour
+      before_create_hook(@resource)
+
+      # TODO: Handle M2M relations in here
+      if @resource.save
+        after_create_hook(@resource)
+        successful_response(:create)
+      else
+        errorful_resopnse(:create, @resource.errors) do
+          redirect_to Rails.application.routes.url_helpers.send(@new_route), turbolinks: true
+        end
+      end
+    end
+
+    protected
+
+      def collect_model_fields_for_form
+        @_fields ||= form_properties.fields_for_form
+      end
+
+      def reflections_hash
+        # TODO: cach the result using and instance_var or something
+        reflections = model.reflections
+        result      = {}
+
+        reflections.each do |name, column|
+          unless is_reflection?(column)
+
+            value = creation_params[column.foreign_key]
+            result[column.foreign_key.to_sym] = value
+          end
+        end
+
+        return result unless result.empty?
+        nil
+      end
+
+      def creation_params
+        resource = controller_name.singularize.underscore.to_sym
+
+        # TODO: replace this line with a better solution to not
+        #       allowing the blacklisted fields like id, created_at and ...
+        fields = model.columns_hash.keys.map(&:to_sym)
+        fields.concat(attachment_fields.map(&:to_sym ))
+        fields = Set.new(fields).map(&:to_sym)
+        params.require(resource).permit(*fields)
+      end
+
+      # Check whether the given column is a reflection or not.
+      def is_reflection?(c)
+        has_many = ActiveRecord::Reflection::HasManyReflection
+        has_and_belongs_to_many = ActiveRecord::Reflection::HasAndBelongsToManyReflection
+        has_many_through = ActiveRecord::Reflection::ThroughReflection
+
+        result = c.is_a?(has_many) || c.is_a?(has_and_belongs_to_many)
+        result || c.is_a?(has_many_through)
+      end
+
+    private
+
+      # You can override this method to change the behaviour of `create`
+      # action before save resource
+      def before_create_hook(resource)
+      end
+
+      # You can override this method to change the behaviour of `create`
+      # action afer save resource
+      def after_create_hook(resource)
+      end
+
+      # You can override this method to change the behaviour of `update`
+      # action before save resource
+      def before_update_hook(resource)
+      end
+
+
+      # You can override this method to change the behaviour of `update`
+      # action after save resource
+      def after_update_hook(resource)
+      end
+
+      # You can override this method to change the behaviour of `new`
+      # action
+      def new_hook(resource)
+      end
+
+      # You can override this method to change the behaviour of `edit`
+      # action
+      def edit_hook(resource)
+      end
+
+      def all_valid_columns_for_form
+        return @all_valid_columns_for_form unless @all_valid_columns_for_form.nil?
+        columns   = model.columns_hash.dup
+        relations = model.reflections
+
+        relations.keys.each do |name|
+          has_many = ActiveRecord::Reflection::HasManyReflection
+          has_and_belongs_to_many = ActiveRecord::Reflection::HasAndBelongsToManyReflection
+
+          unless relations[name].is_a? has_many
+            if relations[name].is_a? has_and_belongs_to_many
+              columns[name] = Class.new { def self.type() :multiple_select end }
+            else
+              col    = relations[name]
+              column = columns.delete col.foreign_key
+              columns[name] = column
+            end
+          end
+        end
+
+        columns.delete('id')
+        columns.delete('created_at')
+        columns.delete('updated_at')
+
+        @all_valid_columns_for_form = columns
+      end
+
+      def form_properties
+        Underworld::Dashboard::DSL::Create.new(model)
+      end
+
+      def _new_form_fields
+        all_valid_columns_for_form.keys.map(&:to_sym)
+      end
+
+    # The actual DSL for index ages
+    module ClassMethods
+
+      # To specify any property and action for `form` section both new and edit
+      # You must use `in_form` class method with block of properties. For
+      # example:
+      #
+      #   class ExamplesController < Dashboard::Application
+      #     in_form do
+      #       attributes :name, :description
+      #       action_button :close, dashboard_example_close_path
+      #     end
+      #   end
+      def in_form(&block)
+        model = model_class
+        form_props = Underworld::Dashboard::DSL::Create.new(model)
+
+        unless block_given?
+          fail ArgumentError, "You have to provide a block for 'in_form'"
+        end
+
+
+        define_method(:form_properties) do
+          unless defined? @__form_props__
+            instance_exec(form_props, &block)
+            @__form_props__ = form_props
+          end
+          return @__form_props__
+        end
+
+        private :form_properties
+      end
+
+      # User can provides the fields that he/she wants to be shown
+      # in the form for resource creation page.
+      # for example:
+      #
+      # class Dashboard::PostsController < Dashboard::ApplicationController
+      #   new_form_fields :title, created_at
+      # end
+      def new_form_fields(*fields, **options)
+        define_method(:_new_form_fields) do
+          fields.map(&:to_sym)
+        end
+
+        private :_new_form_fields
+      end
+
+      def form_fields
+        form = ::Underworld::Dashboard::FormFieldsProperties.new
+        yield form
+
+        define_method(:_form_fields) do
+          form
+        end
+
+        private :_form_fields
+      end
+    end
+  end
+end