constructor-pages 1.0.0beta1 → 1.0.0beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 076592077cf4756361ca5c20ab57059950ffc7f5
-  data.tar.gz: b6fdd943392882e13f845a80b61a02696a449230
+  metadata.gz: f675af9c0fbb73b082bfa366e4f96428ef9c9b0e
+  data.tar.gz: 6c2a949553d8d3aca605e8b7b5e9c19fcb045139
 SHA512:
-  metadata.gz: ad18e8a26816becc289dd612ddd8270cdc3babacb8deb4b792f0e108e557fcec13138135b49fc1ab2cf4c430f3f97e17c0c8ef3ef36d579a36594cbb487577d3
-  data.tar.gz: 72d2db5db1bd322ec155f42e77284b1e952f002692f485f848a5b1ef34afa42d62c442abddc5cb342fce915ab9a1fb81776fe812ec0e4b36c710fe8f9ff9a0d8
+  metadata.gz: c012caaa5894b41848bed34798e3a9dbdbe98690321eb5eb2e2b3546a83b4545ed04b83f4b1f1070198dd77f8c6a38b7efd46c840618161a4dbdaf91241a946a
+  data.tar.gz: 17091449e7387cf48d44d91005c6391be092434e92715bd4d3696c6f6d531a6dda1cdd33efb88aee8b95feefeebb31830b0cee9c9687cd2bb352ad9420189ae3

data/app/assets/javascripts/constructor_pages/urlify.js

@@ -69,6 +69,7 @@ function URLify(s, num_chars) {
     s = s.replace(/[^-\w\s]/g, '-');  // remove unneeded chars
     s = s.replace(/^\s+|\s+$/g, ''); // trim leading/trailing spaces
     s = s.replace(/[-\s]+/g, '-');   // convert spaces to hyphens
+    s = s.replace(/^-+|-+$/g, '');   // trim leading/trailing hyphens
     s = s.toLowerCase();             // convert to lowercase
     return s.substring(0, num_chars);// trim to first num_chars chars
 }

data/app/controllers/constructor_pages/fields_controller.rb

@@ -1,68 +1,62 @@
-# encoding: utf-8
-
 module ConstructorPages
   class FieldsController < ConstructorCore::ApplicationController
     include TheSortableTreeController::Rebuild
     include TheSortableTreeController::ExpandNode
 
+    before_action :set_field, only: [:edit, :update, :destroy]
+
     def new
-      @field = Field.new.tap {|f| @template = f.template = Template.find(params[:template_id])}
+      @field = Field.new template_id: params[:template_id]
     end
 
     def edit
-      @field = Field.find(params[:id]).tap {|f| @template = f.template = Template.find(params[:template_id])}
     end
 
     def create
       @field = Field.new field_params
-      @template = @field.template
 
       if @field.save
-        redirect_to edit_template_path(@template), notice: t(:field_success_added, name: @field.name)
+        redirect_to edit_template_path(@field.template), notice: t(:field_success_added, name: @field.name)
       else
-        render action: :new
+        render :new
       end
     end
 
     def update
-      @field = Field.find params[:id]
-      @template = @field.template
-
       unless @field.type_value == params[:field][:type_value]
         @field.type_class.where(field_id: @field.id).each do |field|
-          "constructor_pages/types/#{params[:field][:type_value]}_type".classify.constantize.new(
-              field_id: @field.id, page_id: field.page_id).tap {|f|
-            f.value = field.value unless [@field.type_value, params[:field][:type_value]].include?('image') and
-                                  (@field.type_value == 'string' and field.value.strip == '')
-            f.save; field.destroy
-          }
+          _field = "constructor_pages/types/#{params[:field][:type_value]}_type".classify.constantize.new(field_id: @field.id, page_id: field.page_id)
+
+          unless [@field.type_value, params[:field][:type_value]].include?('image') && (@field.type_value == 'string' && field.value.strip == '')
+            _field.value = field.value
+          end
+
+          _field.save
+          field.destroy
         end
       end
 
       if @field.update field_params
-        redirect_to edit_template_path(@template.id), notice: t(:field_success_updated, name: @field.name)
+        redirect_to edit_template_path(@field.template.id), notice: t(:field_success_updated, name: @field.name)
       else
-        render action: :edit
+        render :edit
       end
     end
 
     def destroy
-      @field = Field.find(params[:id])
-      name, template = @field.name, @field.template.id
       @field.destroy
-      redirect_to edit_template_url(template), notice: t(:field_success_removed, name: name)
+      redirect_to edit_template_url(@field.template), notice: t(:field_success_removed, name: @field.name)
     end
 
-    def sortable_model
-      Field
-    end
-
-    def sortable_collection
-      ConstructorPages::Field
-    end
+    def sortable_model; Field end
+    def sortable_collection; ConstructorPages::Field end
 
     private
 
+    def set_field
+      @field = Field.find params[:id]
+    end
+
     def field_params
       params.require(:field).permit(
           :name,

data/app/controllers/constructor_pages/pages_controller.rb

@@ -1,95 +1,71 @@
-# encoding: utf-8
-
 module ConstructorPages
   class PagesController < ConstructorCore::ApplicationController
     include TheSortableTreeController::Rebuild
     include TheSortableTreeController::ExpandNode
 
-    layout 'constructor_core/application_core', except: [:show]
+    skip_before_filter :authenticate_user!, only: [:show]
 
-    before_filter -> {@pages = Page.all}, only: [:new, :edit]
+    before_action :set_page, only: [:edit, :update, :destroy]
 
     def index
-      @pages = Page.nested_set.roots.includes(:template)
-      @pages_cache = Digest::MD5.hexdigest(@pages.map{|p| [p.id, p.name, p.full_url, p.in_url, p.template.lft, p.lft, p.template_id]}.join)
-      @template_exists = Template.count != 0
-      flash[:notice] = 'Create at least one template' unless @template_exists
+      @pages = Page.roots
     end
 
     def new
-      @page = Page.new
+      @page, @templates = Page.new, Template.all
+
+      if @templates.blank?
+        redirect_to pages_path, notice: t(:create_template_first)
+      end
     end
 
     def show
-      _request = "/#{params[:all]}"
-      @page = Page.find_by_request_or_first(_request)
-      error_404 and return if @page.nil? or (!@page.published? and _request != '/')
+      @page = Page.find_by_path request.path
+
       redirect_to(@page.redirect) && return if @page.redirect?
+
       _code_name = @page.template.code_name
       instance_variable_set('@'+_code_name, @page)
 
-      respond_to do |format|
-        format.html { render "#{_code_name.pluralize}/show" rescue render "templates/#{_code_name}"}
-        format.json { render "#{_code_name.pluralize}/show.json", layout: false rescue render json: @page }
-        format.xml  { render "#{_code_name.pluralize}/show.xml",  layout: false rescue render xml: @page }
-      end
+      render "templates/#{_code_name}", layout: 'application'
     end
 
     def edit
-      @page = Page.find(params[:id])
-      @parent_id, @template_id = @page.parent.try(:id), @page.template.id
-      _code_name = @page.template.code_name.pluralize
-      render "#{_code_name}/edit" rescue render :edit
     end
 
     def create
       @page = Page.new page_params
 
       if @page.save
-        @page.touch_branch
         redirect_to pages_path, notice: t(:page_success_added, name: @page.name)
       else
-        if @page.template_id
-          _template = Template.find(@page.template_id)
-          _code_name = _template.code_name.pluralize if _template
-          render "#{_code_name}/new" rescue render :new
-        else
-          render :new
-        end
+        render :new
       end
     end
 
     def update
-      @page = Page.find params[:id]
-
-      _template_changed = @page.template.id != params[:page][:template_id].to_i
-
-      @page.remove_fields_values if _template_changed
-
       if @page.update page_params
-        @page.create_fields_values if _template_changed
         @page.update_fields_values params[:fields]
-        @page.touch_branch
 
         redirect_to pages_path, notice: t(:page_success_updated, name: @page.name)
       else
-        render "#{@page.template.code_name.pluralize}/new" rescue render :edit
+        render :edit
       end
     end
 
     def destroy
-      @page = Page.find(params[:id])
-      @page.touch_branch
       @page.destroy
       redirect_to pages_path, notice: t(:page_success_removed, name: @page.name)
     end
 
-    def sortable_model
-      Page
-    end
+    def sortable_model; Page end
 
     private
 
+    def set_page
+      @page = Page.find params[:id]
+    end
+
     def page_params
       params.require(:page).permit(
           :active,
@@ -99,7 +75,6 @@ module ConstructorPages
           :keywords,
           :description,
           :auto_url,
-          :parent_id,
           :template_id,
           :in_nav,
           :in_map,
@@ -108,9 +83,5 @@ module ConstructorPages
           :redirect
       )
     end
-
-    def error_404
-      render file: "#{Rails.root}/public/404", layout: false, status: :not_found
-    end
   end
 end

data/app/controllers/constructor_pages/templates_controller.rb

@@ -1,15 +1,12 @@
-# encoding: utf-8
-
 module ConstructorPages
   class TemplatesController < ConstructorCore::ApplicationController
     include TheSortableTreeController::Rebuild
     include TheSortableTreeController::ExpandNode
 
-    before_filter -> {@templates = Template.all}, only: [:new, :edit, :update, :create]
+    before_action :set_template, only: [:edit, :update, :destroy]
 
     def index
       @templates = Template.roots
-      @templates_cache = Digest::MD5.hexdigest(@templates.map{|t| [t.id, t.name, t.lft]}.join)
     end
 
     def new
@@ -17,7 +14,6 @@ module ConstructorPages
     end
 
     def edit
-      @template = Template.find(params[:id])
     end
 
     def create
@@ -31,8 +27,6 @@ module ConstructorPages
     end
 
     def update
-      @template = Template.find params[:id]
-
       if @template.update template_params
         redirect_to templates_url, notice: t(:template_success_updated, name: @template.name)
       else
@@ -41,28 +35,22 @@ module ConstructorPages
     end
 
     def destroy
-      @template = Template.find(params[:id])
-
-      if @template.pages.count == 0
-        name = @template.name
-        @template.destroy
-        redirect_to templates_url, notice: t(:template_success_removed, name: name)
-      else
-        redirect_to :back, alert: t(:template_error_delete_pages)
-      end
+      @template.destroy
+      redirect_to templates_url, notice: t(:template_success_removed, name: @template.name)
     end
 
-    def sortable_model
-      Template
-    end
+    def sortable_model; Template end
 
     private
 
+    def set_template
+      @template = Template.find params[:id]
+    end
+
     def template_params
       params.require(:template).permit(
           :name,
           :code_name,
-          :parent_id,
           :child_id
       )
     end

data/app/helpers/constructor_pages/fields_helper.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ConstructorPages
   module FieldsHelper
     def types_value

data/app/helpers/constructor_pages/pages_helper.rb

@@ -1,14 +1,7 @@
 module ConstructorPages
   module PagesHelper
-    include ForSelect
-
-    def templates
-      Template.all.map{|t| ["#{'--'*t.level} #{t.name}", t.id]}
-    end
-
-    def image_tag_with_at2x(name_at_1x, options={})
-      name_at_2x = name_at_1x.gsub(%r{\.\w+$}, '@2x\0')
-      image_tag(name_at_1x, options.merge("data-at2x" => asset_path(name_at_2x)))
+    def templates_tree(templates)
+      templates.map{|t| ["#{'--'*t.level} #{t.name}", t.id]}
     end
   end
 end

data/app/models/constructor_pages/field.rb

@@ -1,15 +1,11 @@
-# encoding: utf-8
-
 module ConstructorPages
   # Field model. Fields allows to add custom fields for template.
   # Each field has type of value such as float, integer, string...
   class Field < ActiveRecord::Base
-    # Adding code_name_uniqueness method
-    include CodeNameUniq
-
     # Array of available field types
-    TYPES = %w{string integer float boolean text date html image}.tap {|_t|
-    _t.each {|t| class_eval %{has_many :#{t}_types, dependent: :destroy, class_name: 'Types::#{t.titleize}Type'}}}
+    TYPES = %w{string integer float boolean text date html image}
+
+    TYPES.each {|t| class_eval %{has_many :#{t}_types, class_name: 'Types::#{t.titleize}Type'} }
 
     validates_presence_of :name
     validates_uniqueness_of :code_name, scope: :template_id
@@ -47,6 +43,11 @@ module ConstructorPages
 
     private
 
+    # Check if code_name is not available
+    def code_name_uniqueness
+      errors.add(:base, :code_name_already_in_use) unless Page.check_code_name(code_name) and check_code_name(code_name)
+    end
+
     # Check if there is code_name in template branch
     def check_code_name(code_name)
       [code_name.pluralize, code_name.singularize].each {|name|
@@ -55,8 +56,21 @@ module ConstructorPages
       true
     end
 
-    # Create and destroy page fields
-    %w{create destroy_all}.each {|m| class_eval %{
-      def #{m}_page_fields; template.pages.each {|page| type_class.#{m} page_id: page.id, field_id: id} end }}
+    def create_page_fields
+      template.page_ids.each_slice(500) do |batch|
+        _items = []
+        batch.each do |_id|
+          _items << type_class.new({page_id: _id, field_id: id})
+        end
+        type_class.import _items
+      end
+    end
+
+    def destroy_all_page_fields
+      template.page_ids.each_slice(1000) do |batch|
+        type_class.where(page_id: batch, field_id: id).delete_all
+        Page.update_all({updated_at: Time.now}, {id: batch})
+      end
+    end
   end
 end

data/app/models/constructor_pages/page.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ConstructorPages
   # Page model. Pages are core for company websites, blogs etc.
   class Page < ActiveRecord::Base
@@ -14,9 +12,12 @@ module ConstructorPages
     has_many :fields, through: :template
     belongs_to :template
 
+    scope :published, -> { where(active: true) }
+
     default_scope -> { order :lft }
 
     validate :templates_existing_check
+    validate :check_template_changing, on: :update
 
     before_save :friendly_url, :assign_template, :full_url_update
     after_update :descendants_update
@@ -25,10 +26,10 @@ module ConstructorPages
     acts_as_nested_set
 
     class << self
-      # Used for find page by request. It return first page if no request given or request is home page
+      # Used for find page by request path. It return first page if no request given or request is home page
       # @param request for example <tt>'/conditioners/split-systems/zanussi'</tt>
-      def find_by_request_or_first(request = nil)
-        (request.nil? || request == '/') ? Page.first : Page.find_by(full_url: request)
+      def find_by_path(path)
+        path == '/' ? Page.published.first! : Page.published.find_by!(full_url: path)
       end
 
       # Generate full_url from parent id and url
@@ -129,12 +130,10 @@ module ConstructorPages
 
     # Update all fields values with given params.
     # @param params should looks like <tt>{price: 500, content: 'Hello'}</tt>
-    # @param reset_booleans reset all boolean fields to false before assign params
-    def update_fields_values(params, reset_booleans = true)
+    def update_fields_values(params)
       params || return
 
       fields.each {|f| f.find_or_create_type_object(self).tap {|t| t || next
-        t.value = 0 if f.type_value == 'boolean' && reset_booleans
         params[f.code_name.to_sym].tap {|v| v && t.value = v}
         t.save }}
     end
@@ -184,11 +183,6 @@ module ConstructorPages
     # Check if link specified
     def redirect?; url != redirect && !redirect.empty? end
 
-    # Touch all pages in same branch
-    def touch_branch
-      [ancestors, descendants].each {|p| p.map(&:touch)}
-    end
-
     # When method missing it get/set field value or get page in branch
     #
     # Examples:
@@ -211,6 +205,9 @@ module ConstructorPages
     # Page is not valid if there is no template
     def templates_existing_check; errors.add_on_empty(:template_id) if Template.count == 0 end
 
+    # Page should not change template
+    def check_template_changing; errors.add(:base, :can_not_change_template) if template_id_changed? end
+
     # If template_id is nil then get first template
     def assign_template; self.template_id = Template.first.id unless template_id end