constructor-core 0.7.0 → 0.7.1

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

@@ -0,0 +1,62 @@
+# 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

@@ -0,0 +1,7 @@
+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

@@ -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/pages_helper.rb

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,59 @@
+# 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

@@ -0,0 +1,173 @@
+# 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 do |name|
+          return false if Page.instance_methods.include?(name.to_sym)
+        end
+
+        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

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module ConstructorPages
+  # Template model. Template allows assing different design for pages.
+  #
+  # Templates has many fields.
+  # For example:
+  #   template "Product" should has fields like "price", "description", "size" etc.
+  class Template < ActiveRecord::Base
+    # Adding code_name_uniqueness method
+    include CodeNameUniq
+
+    validates_presence_of :name, :code_name
+    validates_uniqueness_of :code_name
+    validate :code_name_uniqueness
+
+    default_scope -> { order :lft }
+
+    has_many :pages, dependent: :destroy
+    has_many :fields, dependent: :destroy
+
+    acts_as_nested_set
+
+    # Return child corresponding child_id or children first
+    def child
+      !child_id && !leaf? ? children.first : self.class.find(child_id)
+    end
+
+    private
+
+    # Check if there is code_name in same branch
+    def check_code_name(cname)
+      [cname.pluralize, cname.singularize].each {|name|
+        return false if root.descendants.map{|t| t.code_name unless t.code_name == cname}.include?(name)}
+      true
+    end
+  end
+end

data/pages/app/models/constructor_pages/types/boolean_type.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module ConstructorPages
+  module Types
+    # Boolean type. Render as checkbox.
+    class BooleanType < ActiveRecord::Base
+      belongs_to :field
+      belongs_to :page
+    end
+  end
+end