releaf-content 0.2.1

data/app/builders/releaf/content/content_type_dialog_builder.rb

@@ -0,0 +1,74 @@
+module Releaf::Content
+  class ContentTypeDialogBuilder
+    include Releaf::Content::Builders::Dialog
+    attr_accessor :content_types
+
+    def initialize(template)
+      super
+      self.content_types = template_variable("content_types")
+    end
+
+    def content_types_slices
+      min_items_per_column = 4
+      items_per_column = (content_types.length / 2.0).ceil
+
+      if items_per_column < min_items_per_column
+        items_per_column = min_items_per_column
+      end
+
+      slices = []
+      slices.push content_types[0...items_per_column]
+      if items_per_column < content_types.length
+        slices.push content_types[items_per_column..-1]
+      end
+
+      slices
+    end
+
+    def section_attributes
+      attributes = super
+      attributes['data-columns'] = content_types_slices.length
+      attributes
+    end
+
+    def section_body
+      tag(:div, class: "body") do
+        [section_body_description, content_types_list]
+      end
+    end
+
+    def content_types_list
+      tag(:div, class: "content-types") do
+        content_types_slices.collect do |slice|
+          content_type_slice(slice)
+        end
+      end
+    end
+
+    def content_type_slice(slice)
+      tag(:ul) do
+        slice.collect do|content_type|
+          content_type_item(content_type)
+        end
+      end
+    end
+
+    def content_type_item(content_type)
+      url = url_for(controller: "/releaf/content/nodes", action: "new", parent_id: params[:parent_id], content_type: content_type.name)
+      tag(:li) do
+        link_to(I18n.t(content_type.name.underscore, scope: 'admin.content_types'), url)
+      end
+    end
+
+
+    def section_body_description
+      tag(:div, class: "description") do
+        t("Select content type of new node")
+      end
+    end
+
+    def section_header_text
+      t("Add new node")
+    end
+  end
+end

data/app/builders/releaf/content/copy_dialog_builder.rb

@@ -0,0 +1,9 @@
+module Releaf::Content
+  class CopyDialogBuilder
+    include Releaf::Content::Builders::ActionDialog
+
+    def action
+      :copy
+    end
+  end
+end

data/app/builders/releaf/content/go_to_dialog_builder.rb

@@ -0,0 +1,9 @@
+module Releaf::Content
+  class GoToDialogBuilder
+    include Releaf::Content::Builders::Dialog
+
+    def section_header_text
+      t("Go to node")
+    end
+  end
+end

data/app/builders/releaf/content/move_dialog_builder.rb

@@ -0,0 +1,9 @@
+module Releaf::Content
+  class MoveDialogBuilder
+    include Releaf::Content::Builders::ActionDialog
+
+    def action
+      :move
+    end
+  end
+end

data/app/builders/releaf/content/nodes/content_form_builder.rb

@@ -0,0 +1,7 @@
+module Releaf::Content::Nodes
+  class ContentFormBuilder < Releaf::Builders::FormBuilder
+    def field_names
+      object.class.acts_as_node_fields
+    end
+  end
+end

data/app/builders/releaf/content/nodes/form_builder.rb

@@ -0,0 +1,108 @@
+module Releaf::Content::Nodes
+  class FormBuilder < Releaf::Builders::FormBuilder
+    def field_names
+      %w(node_fields_block content_fields_block)
+    end
+
+    def node_fields
+      [:parent_id, :name, :content_type, :slug, :item_position, :active, :locale]
+    end
+
+    def render_node_fields_block
+      tag(:div, class: ["section", "node-fields"]) do
+        releaf_fields(node_fields)
+      end
+    end
+
+    def render_parent_id
+      hidden_field(:parent_id) if object.new_record?
+    end
+
+    def render_content_fields_block?
+      object.content_class.respond_to?(:acts_as_node_fields)
+    end
+
+    def render_content_fields_block
+      return unless render_content_fields_block?
+      tag(:div, class: ["section", "content-fields"]) do
+        fields_for(:content, object.content, builder: content_builder_class) do |form|
+          form.releaf_fields(form.field_names.to_a)
+        end
+      end
+    end
+
+    def content_builder_class
+      Releaf::Content::Nodes::ContentFormBuilder
+    end
+
+    def render_locale
+      releaf_item_field(:locale, options: render_locale_options) if object.locale_selection_enabled?
+    end
+
+    def render_locale_options
+      {
+        select_options: I18n.available_locales,
+        include_blank: object.locale.blank?
+      }
+    end
+
+    def render_content_type
+      input = {disabled: true, value: t(object.content_type.underscore, scope: 'admin.content_types')}
+      releaf_text_field(:content_type, input: input) do
+        hidden_field_tag(:content_type, params[:content_type]) if object.new_record?
+      end
+    end
+
+    def render_slug
+      url = url_for(controller: "/releaf/content/nodes", action: "generate_url", parent_id: object.parent_id, id: object.id)
+      input = {
+        data: {'generator-url' => url}
+      }
+
+      releaf_field(:slug, input: input) do
+        slug_button << wrapper(slug_link, class: "link")
+      end
+    end
+
+    def render_item_position
+      releaf_item_field(:item_position, options: item_position_options)
+    end
+
+    def item_position_options
+      {
+        include_blank: false,
+        select_options: options_for_select(item_position_select_options, object.item_position)
+      }
+    end
+
+    def item_position_select_options
+      after_text = t("After")
+      list = [[t("First"), 0]]
+      order_nodes.each do |node|
+        list.push [after_text + ' ' + node.name, node.lower_item ? node.lower_item.item_position : node.item_position + 1 ]
+      end
+
+      list
+    end
+
+    def order_nodes
+      object.class.where(parent_id: object.parent_id).where('id <> ?',  object.id.to_i)
+    end
+
+    def slug_base_url
+      "#{request.protocol}#{request.host_with_port}#{object.parent.try(:path)}/"
+    end
+
+    def slug_link
+      link_to(object.path) do
+        safe_join do
+          [slug_base_url, tag(:span, object.slug), '/']
+        end
+      end
+    end
+
+    def slug_button
+      button(nil, "keyboard-o", title: t('Suggest slug'), class: "secondary generate")
+    end
+  end
+end

data/app/builders/releaf/content/nodes/index_builder.rb

@@ -0,0 +1,24 @@
+module Releaf::Content::Nodes
+  class IndexBuilder < Releaf::Builders::IndexBuilder
+    include Releaf::Content::Builders::Tree
+    include Releaf::Builders::Toolbox
+
+    def tree_resource_blocks(resource, level, expanded)
+      [tree_resource_toolbox(resource)] + super
+    end
+
+    def tree_resource_toolbox(resource)
+      tag(:div, class: "only-icon toolbox-cell") do
+        toolbox(resource, index_url: index_url)
+      end
+    end
+
+    def pagination?
+      false
+    end
+
+    def resource_creation_button
+      button(t("Create new resource"), "plus", class: %w(primary ajaxbox), href: url_for(controller: controller.controller_name, action: "content_type_dialog"))
+    end
+  end
+end

data/app/builders/releaf/content/nodes/toolbox_builder.rb

@@ -0,0 +1,33 @@
+module Releaf::Content::Nodes
+  class ToolboxBuilder < Releaf::Builders::ToolboxBuilder
+    def items
+      list = []
+
+      unless resource.new_record?
+        list << add_child_button
+        list << go_to_button unless params[:context] == "index"
+        list << copy_button
+        list << move_button
+      end
+
+      list + super
+    end
+
+    def add_child_button
+      button(t('Add child'), nil, class: "ajaxbox", href: url_for(action: "content_type_dialog", parent_id: resource.id))
+    end
+
+    def go_to_button
+      button(t('Go to'), nil, class: "ajaxbox", href: url_for(action: "go_to_dialog"))
+    end
+
+    def copy_button
+      button(t('Copy'), nil, class: "ajaxbox", href: url_for(action: "copy_dialog", id: resource.id))
+    end
+
+    def move_button
+      button(t('Move'), nil, class: "ajaxbox", href: url_for(action: "move_dialog", id: resource.id))
+    end
+
+  end
+end

data/app/controllers/releaf/content/nodes_controller.rb

@@ -0,0 +1,166 @@
+module Releaf::Content
+  class NodesController < Releaf::BaseController
+    respond_to :json, only: [:create, :update, :copy, :move]
+
+    def setup
+      super
+      @features[:create_another] = false
+    end
+
+    def generate_url
+      tmp_resource = prepare_resource
+      tmp_resource.name = params[:name]
+      tmp_resource.reasign_slug
+
+      respond_to do |format|
+        format.js { render text: tmp_resource.slug }
+      end
+    end
+
+    def content_type_dialog
+      @content_types = resource_class.valid_node_content_classes(params[:parent_id]).sort do |a, b|
+        I18n.t(a.name.underscore, scope: 'admin.content_types') <=> I18n.t(b.name.underscore, scope: 'admin.content_types')
+      end
+    end
+
+    def builder_scopes
+      [node_builder_scope] + super
+    end
+
+    def node_builder_scope
+      [application_scope, "Nodes"].reject(&:blank?).join("::")
+    end
+
+    def copy_dialog
+      copy_move_dialog_common
+    end
+
+    def move_dialog
+      copy_move_dialog_common
+    end
+
+    def copy
+      copy_move_common do |resource|
+        resource.copy params[:new_parent_id]
+      end
+    end
+
+    def move
+      copy_move_common do |resource|
+        resource.move params[:new_parent_id]
+      end
+    end
+
+    def go_to_dialog
+      @collection = resource_class.roots
+
+      respond_to do |format|
+        format.html do
+          render layout: nil
+        end
+      end
+    end
+
+    # override base_controller method for adding content tree ancestors
+    # to breadcrumbs
+    def add_resource_breadcrumb(resource)
+      ancestors = []
+      if resource.new_record?
+        if resource.parent_id
+          ancestors = resource.parent.ancestors
+          ancestors += [resource.parent]
+        end
+      else
+        ancestors = resource.ancestors
+      end
+
+      ancestors.each do |ancestor|
+        @breadcrumbs << { name: ancestor, url: url_for( action: :edit, id: ancestor.id ) }
+      end
+
+      super
+    end
+
+    def self.resource_class
+      ::Node
+    end
+
+    protected
+
+    def prepare_index
+      @collection = resource_class.roots
+    end
+
+    private
+
+    def copy_move_common(&block)
+      @resource = resource_class.find(params[:id])
+
+      if params[:new_parent_id].nil?
+        @resource.errors.add(:base, 'parent not selected')
+        respond_with(@resource)
+      else
+        begin
+          @resource = yield(@resource)
+        rescue ActiveRecord::RecordInvalid => e
+          respond_with(e.record)
+        else
+          resource_class.updated
+          respond_with(@resource, redirect: true, location: url_for(action: :index))
+        end
+      end
+    end
+
+    def action_responders
+      super.merge(
+        copy: Releaf::Core::Responders::AfterSaveResponder,
+        move: Releaf::Core::Responders::AfterSaveResponder
+      )
+    end
+
+    def copy_move_dialog_common
+      @resource = resource_class.find params[:id]
+      @collection = resource_class.roots
+    end
+
+    def prepare_resource
+      if params[:id]
+        resource_class.find(params[:id])
+      elsif params[:parent_id].present?
+        parent = resource_class.find(params[:parent_id])
+        parent.children.new
+      else
+        resource_class.new
+      end
+    end
+
+    def new_resource
+      super
+      @resource.content_type = node_content_class.name
+      @resource.parent_id = params[:parent_id]
+      @resource.item_position ||= resource_class.children_max_item_position(@resource.parent) + 1
+
+      if node_content_class < ActiveRecord::Base
+        @resource.build_content
+        @resource.content_id_will_change!
+      end
+    end
+
+    # Returns valid content type class
+    def node_content_class
+      raise ArgumentError, "invalid content_type" unless ActsAsNode.classes.include? params[:content_type]
+      params[:content_type].constantize
+    end
+
+    def permitted_params
+      list = super
+      list += [{content_attributes: permitted_content_attributes}]
+      list -= %w[content_type]
+      list
+    end
+
+    def permitted_content_attributes
+      @resource.content_class.acts_as_node_params if @resource.content_class.respond_to? :acts_as_node_params
+    end
+  end
+end