constructor-cms 0.5.7 → 0.5.8

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

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+module ConstructorPages
+  class PagesController < ConstructorCore::ApplicationController
+    include MoveHelper
+    caches_page :show
+
+    before_filter {@roots = Page.roots}
+    before_filter :cache, only: [:create, :update, :destroy, :move_up, :move_down]
+
+    def new
+      @page, @template_id, @multipart = Page.new, Template.first.id, false
+
+      if params[:page] and (@page.parent = Page.find(params[:page]))
+        @template_id = @page.parent.template.child.id
+      end
+    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
+
+=begin
+    def search
+      if params[:all].nil?
+        @page = Page.first
+      else
+        @request = '/' + params[:all]
+        @page = Page.where(:full_url => @request).first
+      end
+
+      instance_variable_set('@'+@page.template.code_name.to_s, @page)
+
+      what_search = params[:what_search]
+      params_selection = request.query_parameters
+
+      template = Template.find_by_code_name(what_search.singularize)
+
+      if template.nil?
+        render :action => "error_404", :layout => false
+        return
+      end
+
+      @pages = @page.descendants.where(:template_id => template.id)
+
+      params_selection.each_pair do |code_name, value|
+        if value.numeric?
+          value = value.to_f
+        elsif value.boolean?
+          value = value.to_bool
+        end
+
+        @pages = @pages.select do |page|
+          if code_name == 'name'
+            page.name == value
+          else
+            page.field(code_name) == value
+          end
+        end
+      end
+
+      instance_variable_set('@'+template.code_name.pluralize, @pages)
+
+      render :template => "templates/#{template.code_name}_search"
+    end
+=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 params[:page]
+
+      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]
+
+      if @page.template.id != params[:page][:template_id].to_i
+        @page.remove_fields_values
+      end
+
+      if @page.update_attributes params[:page]
+        @page.create_fields_values
+        @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
+
+    %w{up down}.each {|m| define_method "move_#{m}" do move_to :page, m.to_sym end}
+
+    private
+
+    def error_404
+      render file: "#{Rails.root}/public/404", layout: false, status: 404
+    end
+
+    def cache
+      expire_page :action => :show
+      cache_dir = ActionController::Base.page_cache_directory
+      unless cache_dir == Rails.root.to_s+"/public"
+        FileUtils.rm_r(Dir.glob(cache_dir+"/*")) rescue Errno::ENOENT
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module ConstructorPages
+  class TemplatesController < ConstructorCore::ApplicationController
+    include MoveHelper
+
+    before_filter {@roots = Template.roots}
+
+    def new
+      @template = Template.new
+
+      if params[:template]
+        @parent = Template.find(params[:template])
+        @template.parent_id = @parent.id
+      end
+    end
+
+    def edit
+      @template = Template.find(params[:id])
+    end
+
+    def create
+      @template = Template.new params[:template]
+
+      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_attributes params[:template]
+        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])
+      name = @template.name
+      @template.destroy
+      redirect_to templates_url, notice: t(:template_success_removed, name: name)
+    end
+
+    %w{up down}.each {|m| define_method "move_#{m}" do move_to :template, m.to_sym end}
+  end
+end

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

@@ -0,0 +1,9 @@
+module ConstructorPages
+  module CodeNameUniq
+    def code_name_uniqueness
+      unless Page.check_code_name(code_name) and check_code_name(code_name)
+        errors.add(:base, :code_name_already_in_use)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# 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/move_helper.rb

@@ -0,0 +1,14 @@
+module ConstructorPages
+  module MoveHelper
+    def move_to(what, to)
+      from = ('constructor_pages/'+what.to_s).classify.constantize.find(params[:id])
+      to_sibling = to == :up ? from.left_sibling : from.right_sibling
+
+      if not to_sibling.nil? and from.move_possible?(to_sibling)
+        to == :up ? from.move_left : from.move_right
+      end
+
+      redirect_to :back
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module ConstructorPages
+  module PagesHelper
+    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

@@ -0,0 +1,11 @@
+module ConstructorPages
+  module TemplatesHelper
+    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/models/constructor_pages/field.rb

@@ -0,0 +1,89 @@
+# 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
+    attr_accessible :name, :code_name, :type_value, :template_id, :template
+
+    # Adding code_name_uniqueness method
+    include CodeNameUniq
+
+    # Array of available field types
+    TYPES = %w{string integer float boolean text date html image}
+
+    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
+
+    belongs_to :template
+
+    # Adding has_many for all field types
+    TYPES.each do |t|
+      class_eval %{
+        has_many :#{t}_types, class_name: 'Types::#{t.titleize}Type'
+      }
+    end
+
+    has_many :pages, through: :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_and_page_id(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)
+      _type_object = find_type_object(page)
+      _type_object ? _type_object.value : nil
+    end
+
+    # Set value type_field for specified page
+    def set_value_for(page, value)
+      _type_object = find_type_object(page)
+
+      if _type_object
+        _type_object.value = value
+        _type_object.save!
+      end
+    end
+
+    private
+
+    # Check if there is code_name in template branch
+    def check_code_name(code_name)
+      [code_name.pluralize, code_name.singularize].each do |name|
+        %w{self_and_ancestors descendants}.each do |m|
+          if template.send(m).map{|t| t.code_name}.include?(name)
+            return false
+          end
+        end
+      end
+
+      true
+    end
+
+    # Create and destroy page fields
+    %w{create destroy_all}.each do |m|
+      class_eval %{
+          def #{m}_page_fields
+            template.pages.each {|page| type_class.#{m} page_id: page.id, field_id: id}
+          end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+# encoding: utf-8
+
+module ConstructorPages
+  # Page model. Pages are core for company websites, blogs etc.
+  class Page < ActiveRecord::Base
+    attr_accessible :name, :title, :keywords, :description,
+                    :url, :full_url, :active, :auto_url,
+                    :parent, :parent_id, :link, :in_menu, :in_map,
+                    :in_nav, :template_id, :template
+
+    # 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
+
+    # Used for find page by request. It return first page if no request given
+    # @param request for example <tt>'/conditioners/split-systems/zanussi'</tt>
+    def self.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 self.full_url_generate(parent_id, url = '')
+      '/' + Page.find(parent_id).self_and_ancestors.map {|c| c.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 self.check_code_name(code_name)
+      [code_name, code_name.pluralize, code_name.singularize].each do |name|
+        if Page.first.respond_to?(name)
+          return false
+        end
+      end
+
+      true
+    end
+
+    # Get field by code_name
+    def field(code_name)
+      Field.find_by_code_name_and_template_id code_name, template_id
+    end
+
+    # Get value of field by code_name
+    def get_field_value(code_name)
+      field = field(code_name)
+      field.get_value_for(self) if field
+    end
+
+    # Set value of field by code_name and value
+    def set_field_value(code_name, value)
+      field = field(code_name)
+      field.set_value_for(self, value) if field
+    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)
+      fields.each do |field|
+        value = params[field.code_name.to_sym]
+
+        _type_object = field.find_type_object(self)
+        _type_object.value = 0 if field.type_value == 'boolean' and reset_booleans
+
+        if value
+          _type_object.value = field.type_value == 'date' ? parse_date(value).to_s : value
+        end
+
+        _type_object.save
+      end
+    end
+
+    # Create fields values
+    def create_fields_values; fields.each {|field| field.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 code_name template code name
+    def find_page_in_branch(code_name)
+      _template = Template.find_by_code_name code_name.singularize
+
+      if _template
+        result = []
+        result = descendants.where(template_id: _template.id) if code_name == code_name.pluralize
+        result = ancestors.find_by_template_id(_template.id) if result.empty?
+        result
+      end
+    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 = {})
+      options = {name: self.name, title: self.title}.merge options
+
+      fields.each do |field|
+        options.merge!({field.code_name.to_sym => field.get_value_for(self)})
+      end
+
+      options
+    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)
+      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: move out
+    def parse_date(value)
+      Date.new(value['date(1i)'].to_i, value['date(2i)'].to_i, value['date(3i)'].to_i)
+    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