constructor-cms 0.7.3 → 0.7.4

data/pages/app/controllers/constructor_pages/fields_controller.rb

@@ -1,70 +0,0 @@
-# encoding: utf-8
-
-module ConstructorPages
-  class FieldsController < ApplicationController
-    def new
-      @field = Field.new.tap {|f| f.template = Template.find(params[:template_id])}
-    end
-
-    def edit
-      @field = Field.find(params[:id]).tap {|f| f.template = Template.find(params[:template_id])}
-    end
-
-    def create
-      @field = Field.new field_params
-
-      if @field.save
-        redirect_to edit_template_path(@field.template_id), notice: t(:field_success_added, name: @field.name)
-      else
-        render action: :new, template_id: @field.template_id
-      end
-    end
-
-    def update
-      @field = Field.find params[:id]
-
-      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
-          }
-        end
-      end
-
-      if @field.update field_params
-        redirect_to edit_template_url(@field.template.id), notice: t(:field_success_updated, name: @field.name)
-      else
-        render action: :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)
-    end
-
-    %w{up down}.each {|m| define_method "move_#{m}" do move_to m.to_sym end}
-
-    private
-
-    def field_params
-      params.require(:field).permit(
-          :name,
-          :code_name,
-          :template_id,
-          :type_value
-      )
-    end
-
-    def move_to(to)
-      @field = Field.find(params[:id])
-      to == :up ? @field.move_higher : @field.move_lower
-      redirect_to :back, notice: t(:field_success_moved, name: @field.name)
-    end
-  end
-end

data/pages/app/controllers/constructor_pages/pages_controller.rb

@@ -1,116 +0,0 @@
-# encoding: utf-8
-
-module ConstructorPages
-  class PagesController < ApplicationController
-    layout 'constructor_core/application_core', except: [:show, :search]
-
-    movable :page
-
-    before_filter {@roots, @template_exists = Page.roots, Template.count > 0}
-
-    def index
-      flash.notice = 'Create at least one template' unless @template_exists
-    end
-
-    def new
-      redirect_to pages_path and return unless @template_exists
-      @page, @template_id, @multipart = Page.new, Template.first.id, false
-      @template_id = @page.parent.template.child.id if params[:page] and (@page.parent = Page.find(params[:page]))
-    end
-
-    def show
-      @page = Page.find_by_request_or_first("/#{params[:all]}")
-      error_404 and return if @page.nil? or !@page.active?
-      redirect_to @page.link if @page.redirect?
-      _code_name = @page.template.code_name.to_s
-      instance_variable_set('@'+_code_name, @page)
-      respond_to do |format|
-        format.html { render template: "html_templates/#{_code_name}" }
-        format.json {
-          _template = render_to_string partial: "json_templates/#{_code_name}.json.erb", layout: false, locals: {_code_name.to_sym => @page, page: @page}
-          _js = render_to_string partial: "js_partials/#{_code_name}.js"
-          render json: @page, self_and_ancestors: @page.self_and_ancestors.map(&:id), template: _template.gsub(/\n/, '\\\\n'), js: _js
-        }
-      end
-    end
-
-    def search
-      @page = Page.find_by_request_or_first("/#{params[:all]}")
-
-      _params = request.query_parameters
-      _params.each_pair {|k,v| v || (_params.delete(k); next)
-        _params[k] = v.numeric? ? v.to_f : (v.to_bool if v.boolean?)}
-
-      @pages = Page.in(@page).by(_params).search(params[:what_search])
-
-      instance_variable_set('@'+@page.template.code_name.pluralize, @pages)
-      instance_variable_set('@'+@page.template.code_name.singularize, @page)
-      render :template => "html_templates/#{@page.template.code_name}_search"
-    end
-
-    def edit
-      @page = Page.find(params[:id])
-      @page.template ||= Template.first
-      @template_id = @page.template.id
-      @multipart = @page.fields.map{|f| f.type_value == 'image'}.include?(true) ? true : false
-    end
-
-    def create
-      @page = Page.new page_params
-
-      if @page.save
-        redirect_to pages.pages_url, notice: t(:page_success_added, name: @page.name)
-      else
-        render action: :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]
-
-        redirect_to pages_url, notice: t(:page_success_updated, name: @page.name)
-      else
-        render action: :edit
-      end
-    end
-
-    def destroy
-      @page = Page.find(params[:id])
-      _name = @page.name
-      @page.destroy
-      redirect_to pages_url, notice: t(:page_success_removed, name: _name)
-    end
-
-    private
-
-    def page_params
-      params.require(:page).permit(
-          :active,
-          :name,
-          :url,
-          :title,
-          :keywords,
-          :description,
-          :auto_url,
-          :parent_id,
-          :template_id,
-          :in_nav,
-          :in_map,
-          :in_menu,
-          :link
-      )
-    end
-
-    def error_404
-      render file: "#{Rails.root}/public/404", layout: false, status: 404
-    end
-  end
-end

data/pages/app/controllers/constructor_pages/templates_controller.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-module ConstructorPages
-  class TemplatesController < ApplicationController
-    include TreeviewHelper
-
-    movable :template
-
-    before_filter {@roots = Template.roots}
-
-    def new
-      @template = Template.new
-    end
-
-    def edit
-      @template = Template.find(params[:id])
-    end
-
-    def create
-      @template = Template.new template_params
-
-      if @template.save
-        redirect_to templates_url, notice: t(:template_success_added, name: @template.name)
-      else
-        render action: :new
-      end
-    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
-        render action: :edit
-      end
-    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
-    end
-
-    private
-
-    def template_params
-      params.require(:template).permit(
-          :name,
-          :code_name,
-          :parent_id,
-          :child_id
-      )
-    end
-  end
-end

data/pages/app/helpers/constructor_pages/code_name_uniq.rb

@@ -1,7 +0,0 @@
-module ConstructorPages
-  module CodeNameUniq
-    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
-  end
-end

data/pages/app/helpers/constructor_pages/fields_helper.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-module ConstructorPages
-  module FieldsHelper
-    def types_value
-      [
-          [t(:string), "string"],
-          [t(:integer), "integer"],
-          [t(:float), "float"],
-          [t(:boolean), "boolean"],
-          [t(:date), "date"],
-          [t(:text), "text"],
-          [t(:html), "html"],
-          [t(:image), "image"]
-      ]
-    end
-  end
-end

data/pages/app/helpers/constructor_pages/pages_helper.rb

@@ -1,22 +0,0 @@
-module ConstructorPages
-  module PagesHelper
-    include TreeviewHelper
-
-    def for_select(roots)
-      result = []
-      roots.each do |r|
-        r.self_and_descendants.each {|i| result.push(["#{'--'*i.level} #{i.name}", i.id, {'data-full_url' => i.full_url}])}
-      end
-      result
-    end
-
-    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)))
-    end
-  end
-end

data/pages/app/helpers/constructor_pages/templates_helper.rb

@@ -1,13 +0,0 @@
-module ConstructorPages
-  module TemplatesHelper
-    include TreeviewHelper
-
-    def for_select(roots)
-      result = []
-      roots.each do |r|
-        r.self_and_descendants.each {|i| result.push(["#{'--'*i.level} #{i.name}", i.id])}
-      end
-      result
-    end
-  end
-end

data/pages/app/helpers/constructor_pages/treeview_helper.rb

@@ -1,33 +0,0 @@
-module ConstructorPages
-  module TreeviewHelper
-    def render_tree(roots, &block)
-      output = '<ul>'
-
-      roots.each do |root|
-        level, last = root.level, nil
-
-        root.self_and_descendants.each do |item|
-          if item.level > level
-            output += '<ul>'
-          elsif item.level < level
-            output += '</li>'
-            output += '</ul></li>' * (level-item.level)
-          elsif !item.root?
-            output += '</li>'
-          end
-
-          output += '<li>'
-
-          output += capture(item, &block)
-
-          level, last = item.level, item
-        end
-
-        output += '</li>'
-        output += '</ul></li>' * last.level
-      end
-
-      output.html_safe
-    end
-  end
-end

data/pages/app/models/constructor_pages/field.rb

@@ -1,59 +0,0 @@
-# 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'}}}
-
-    validates_presence_of :name
-    validates_uniqueness_of :code_name, scope: :template_id
-    validate :code_name_uniqueness
-
-    after_create :create_page_fields
-    after_destroy :destroy_all_page_fields
-
-    has_many :pages, through: :template
-    belongs_to :template
-
-    acts_as_list scope: :template_id
-    default_scope -> { order :position }
-
-    # Return constant of model type_value
-    def type_class; "constructor_pages/types/#{type_value}_type".classify.constantize end
-
-    # Return object of type_value by page
-    def find_type_object(page); type_class.find_by(field_id: id, page_id: page.id) end
-
-    # Create object of type_value by page
-    def create_type_object(page); type_class.create(field_id: id, page_id: page.id) end
-
-    # Remove all type_fields values for specified page
-    def remove_type_object(page); find_type_object(page).destroy end
-
-    # Get value from type_field for specified page
-    def get_value_for(page); find_type_object(page).tap {|t| return t && t.value} end
-
-    # Set value type_field for specified page
-    def set_value_for(page, value); find_type_object(page).tap {|t| t || return; t.update value: value} end
-
-    private
-
-    # Check if there is code_name in template branch
-    def check_code_name(code_name)
-      [code_name.pluralize, code_name.singularize].each {|name|
-        %w{self_and_ancestors descendants}.each {|m|
-          return false if template.send(m).map(&:code_name).include?(name)}}
-      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 }}
-  end
-end

data/pages/app/models/constructor_pages/page.rb

@@ -1,171 +0,0 @@
-# encoding: utf-8
-
-module ConstructorPages
-  # Page model. Pages are core for company websites, blogs etc.
-  class Page < ActiveRecord::Base
-    # Adding has_many for all field types
-    Field::TYPES.each do |t|
-      class_eval %{has_many :#{t}_types,  dependent: :destroy, class_name: 'Types::#{t.titleize}Type'}
-    end
-
-    has_many :fields, through: :template
-    belongs_to :template
-
-    default_scope -> { order :lft }
-
-    validate :template_check
-
-    before_save :friendly_url, :template_assign, :full_url_update
-    after_update :descendants_update
-    after_create :create_fields_values
-
-    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
-      # @param request for example <tt>'/conditioners/split-systems/zanussi'</tt>
-      def find_by_request_or_first(request = nil)
-        request == nil || '/' ? Page.first : Page.find_by(full_url: request)
-      end
-
-      # Generate full_url from parent id and url
-      # @param parent_id integer
-      # @param url should looks like <tt>'hello-world-page'</tt> without leading slash
-      def full_url_generate(parent_id, url = '')
-        '/' + Page.find(parent_id).self_and_ancestors.map(&:url).append(url).join('/')
-      end
-
-      # Check code_name for field and template.
-      # When missing method Page find field or page in branch with plural and singular code_name so
-      # field and template code_name should be uniqueness for page methods
-      def check_code_name(code_name)
-        [code_name, code_name.pluralize, code_name.singularize].each {|name|
-          return false if Page.instance_methods.include?(name.to_sym)}
-        true
-      end
-
-      def search(what_search = nil)
-        (@where_search.is_a?(String) ? Page.find_by(full_url: @where_search) : @where_search)
-        .tap {|p| @result = @where_search ? p ? p.descendants : [] : Page.all }
-        what_search && Template.find_by(code_name: what_search.to_s.singularize.downcase)
-        .tap {|t| @result = t ? @result.where(template: t) : [] }
-        @params_search && @params_search.each_pair {|k,v| @result = @result.select {|p| p.send(k) == v}}
-        @where_search = @params_search = nil
-        @result
-      end
-
-      def in(where_search  = nil); tap {@where_search  = where_search}  end
-      def by(params_search = nil); tap {@params_search = params_search} end
-
-      def search_in(where_search  = nil); self.in(where_search).search  end
-      def search_by(params_search = nil); self.by(params_search).search end
-    end
-
-    def search(what_search = nil); Page.in(self).search(what_search) end
-    def by(params_search = nil); Page.by(params_search); self end
-    def search_by(params_search = nil); Page.by(params_search).in(self).search end
-
-    # Get field by code_name
-    def field(code_name)
-      Field.find_by code_name: code_name, template_id: template_id
-    end
-
-    # Get value of field by code_name
-    def get_field_value(code_name)
-      field(code_name).tap {|f| return f.get_value_for(self) if f}
-    end
-
-    # Set value of field by code_name and value
-    def set_field_value(code_name, value)
-      field(code_name).tap {|f| f.set_value_for(self, value) if f}
-    end
-
-    # 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)
-      params || return
-
-      fields.each {|f| f.find_type_object(self).tap {|t| t || break
-        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
-
-    # Create fields values
-    def create_fields_values; fields.each {|f| f.create_type_object self} end
-
-    # Remove all fields values
-    def remove_fields_values; fields.each {|f| f.remove_type_object self} end
-
-    # Search page by template code_name in same branch of pages and templates.
-    # It allows to call page.category.brand.series.model etc.
-    #
-    # Return one page if founded in ancestors,
-    # and return array of pages if founded in descendants
-    #
-    # It determines if code_name is singular or nor
-    # @param cname template code name
-    def find_page_in_branch(cname)
-      Template.find_by(code_name: cname.singularize).tap {|t| t || return
-        (descendants.where(template_id: t.id) if cname == cname.pluralize).tap {|r| r ||= []
-          return r.empty? ? ancestors.find_by(template_id: t.id) : r}}
-    end
-
-    alias_method :find_pages_in_branch, :find_page_in_branch
-
-    def published?; active end
-
-    alias_method :active?, :published?
-
-    # Returns page hash attributes with fields.
-    #
-    # Default attributes are name and title. Options param allows to add more.
-    # @param options default merge name and title page attributes
-    def as_json(options = {})
-      {name: self.name, title: self.title}.merge(options).tap do |options|
-        fields.each {|f| options.merge!({f.code_name.to_sym => f.get_value_for(self)})}
-      end
-    end
-
-    # Check if link specified
-    def redirect?; url != link && !link.empty? end
-
-    # When method missing it get/set field value or get page in branch
-    #
-    # Examples:
-    #   page.content = 'Hello world'
-    #   puts page.price
-    #   page.brand.models.each do...
-    def method_missing(name, *args, &block)
-      super && return if new_record?
-      name = name.to_s
-      name[-1] == '=' ? set_field_value(name[0..-2], args[0]) : get_field_value(name) || find_pages_in_branch(name)
-    end
-
-    private
-
-    # if url has been changed by manually or url is empty
-    def friendly_url
-      self.url = ((auto_url || url.empty?) ? translit(name) : url).parameterize
-    end
-
-    # TODO: add more languages
-    # translit to english
-    def translit(str); Russian.translit(str) end
-
-    # Page is not valid if there is no template
-    def template_check; errors.add_on_empty(:template_id) if Template.count == 0 end
-
-    # If template_id is nil then get first template
-    def template_assign; self.template_id = Template.first.id unless template_id end
-
-    # Update full_url
-    def full_url_update
-      self.full_url = (parent_id ? Page.full_url_generate(parent_id, url) : '/' + url)
-    end
-
-    # Reload all descendants
-    def descendants_update; descendants.map(&:save) end
-  end
-end