porthos 3.0.0.beta

data/app/models/node.rb

@@ -0,0 +1,106 @@
+class Node
+  include MongoMapper::Document
+  plugin MongoMapper::Plugins::IdentityMap
+  plugin MongoMapper::Plugins::Tree
+
+  self.tree_order = :position.asc
+
+  key :name, String
+  key :slug, String
+  key :url, String
+  key :controller, String
+  key :action, String
+  key :status, Integer
+  key :restricted, Boolean, :default => lambda{ false }
+  key :position, Integer
+
+  key :resource_id, ObjectId
+  key :resource_type, String
+  key :handle, String
+
+  belongs_to :resource,
+             :polymorphic => true
+
+  validates :handle,
+            :uniqueness => true,
+            :allow_blank => true
+
+  validates :url,
+            :presence => true,
+            :uniqueness => true,
+            :if => Proc.new { !Node.count.zero? }
+
+  validates :controller, :presence => true
+  validates :action, :presence => true
+
+  after_save :generate_url_for_children
+  before_save :ensure_position
+  before_validation :generate_url
+
+  def access_status
+    @access_status ||= case status
+    when -1 then 'inactive'
+    when  0 then 'hidden'
+    when  1 then 'active'
+    end
+  end
+
+  def active?
+    access_status == 'active'
+  end
+
+  def hidden?
+    access_status == 'hidden'
+  end
+
+  def inactive?
+    access_status == 'inactive'
+  end
+
+  class << self
+
+    def for_item(item)
+      self.new.tap do |node|
+        node.name = item.title
+        node.controller = 'pages'
+        if item.class == Section
+          node.action = 'index'
+          node.handle = item.page_template.handle
+        else
+          node.action = 'show'
+        end
+        node.resource = item
+        node.parent = Node.root if node.parent_id.blank?
+      end
+    end
+
+    def root
+      roots.any? ? roots.first : nil
+    end
+
+  end
+
+private
+
+  def generate_url
+    if parent
+      new_url = slug.blank? ? name.to_s.to_url : slug
+      self.url = !parent.parent_id.blank? ? [parent.url, new_url].join('/') : new_url
+    end
+  end
+
+  def generate_url_for_children
+    children.each(&:save) if changes.keys.include?('url') && children.any?
+  end
+
+  def ensure_position
+    if self.position.blank?
+      self.position = if siblings.any?
+        siblings.collect { |s| s.position.to_i }.sort.last+1
+      else
+        0
+      end
+    end
+  end
+
+end

data/app/models/observers/node_observer.rb

@@ -0,0 +1,9 @@
+class NodeObserver < Porthos::MongoMapper::Observer
+
+  def after_update(node)
+    LinkList.collection.update({ 'links.node_id' => node.id }, {
+      '$set' => { 'links.$.node_url' => "/#{node.url}" }
+    }, multi: true)
+  end
+
+end

data/app/models/page.rb

@@ -0,0 +1,167 @@
+# -*- coding: UTF-8 -*-
+class Page < Section
+  class_attribute :sortable_keys
+  self.sortable_keys = [
+    :created_at,
+    :updated_at,
+    :published_on,
+    :position
+  ]
+
+  plugin Porthos::MongoMapper::Plugins::Instructable
+  tankit Porthos.config.tanking.index_name do
+    indexes :title
+    indexes :uri
+    indexes :tag_names
+    indexes :data
+  end
+  key :position, Integer
+
+  before_create :move_to_list_bottom
+
+  scope :with_page_template, lambda { |page_template_id|
+    where(:page_template_id => page_template_id)
+  }
+
+  scope :is_published, lambda { |is_published|
+    if Boolean.to_mongo(is_published)
+      where(:published_on.lte => Time.now)
+    else
+      where(:published_on => nil)
+    end
+  }
+
+  scope :include_restricted, lambda { |restricted|
+    where(:$or => [{:restricted => restricted}, { :restricted => false}])
+  }
+
+  def section
+    @section ||= Section.where(page_template_id: self.page_template_id).first
+  end
+
+  def can_have_a_node?
+    published_on.present? && page_template.allow_node_placements? && node.blank?
+  end
+
+  def has_url?
+    published? and (node.present? or index_node.present?)
+  end
+
+  def index_node
+    @index_node ||= Node.where(controller: 'pages', action: 'index', handle: self.page_template.handle)
+  end
+
+  def in_restricted_context?
+    @in_restricted_context ||= restricted? || node_restricted? || index_node_restricted?
+  end
+
+  def category
+    @category ||= page_template.allow_categories? ? tags(page_template.handle).first : nil
+  end
+
+  def category_name
+    @category_name ||= category ? category.name : ''
+  end
+
+  def category_method_name
+    @category_method_name ||= "#{page_template.handle}_tag_names"
+  end
+
+
+  def sortable
+    page_template ? page_template.sortable : nil
+  end
+
+  def sortable?
+    sortable.present?
+  end
+
+  # About next and previous, think of it as a list
+  # When using ascending   #   When using descending
+  #         1              #          4
+  #         2              #   next ↓ 3 ↑ previous
+  #  next ↓ 3 ↑ previous   #          2
+  #         4              #          1
+  #
+
+  def previous
+    if sortable?
+      get_next_or_previous(*previous_operators).first
+    end
+  end
+
+  def next
+    if sortable?
+      get_next_or_previous(*next_operators).first
+    end
+  end
+
+  def previous_in_category
+    if sortable?
+      get_next_or_previous(*previous_operators).where({
+        :'_tags.name'.all => [category_name],
+        :'_tags.namespace' => page_template.handle
+      }).first
+    end
+  end
+
+  def next_in_category
+    if sortable?
+      get_next_or_previous(*next_operators).where({
+        :'_tags.name'.all => [category_name],
+        :'_tags.namespace' => page_template.handle
+      }).first
+    end
+  end
+
+  class << self
+    def from_template(template, attributes = {})
+      self.new(attributes.merge(template.shared_attributes)).tap do |page|
+        page.data = template.datum_templates.map do |datum_template|
+          datum_template.datum_class.constantize.from_template(datum_template)
+        end
+      end
+    end
+
+    def create_from_template(template, attributes = {})
+      self.from_template(template, attributes).tap do |page|
+        page.save
+      end
+    end
+  end
+
+private
+
+  def previous_operators
+    sortable.operator == 'desc' ? ['gt', 'asc'] : ['lt', 'desc']
+  end
+
+  def next_operators
+    sortable.operator == 'desc' ? ['lt', 'desc'] : ['gt', 'asc']
+  end
+
+  def get_next_or_previous(compare_operator, sort_operator)
+    Page.limit(1).published.where({
+      :page_template_id => self.page_template_id,
+      sortable.field.public_send(compare_operator) => self[sortable.field]
+    }).sort(sortable.field.public_send(sort_operator))
+  end
+
+  def move_to_list_bottom
+    if sortable && sortable.field == :position
+      last_in_list = Page.where(page_template_id: self.page_template_id).
+        sort(:position.desc).
+        fields(:position).limit(1).
+        first
+      self.position = last_in_list ? last_in_list.position.to_i + 1 : 1
+    end
+  end
+
+  def node_restricted?
+    node && (node.restricted? || node.ancestors.detect { |n| n.restricted? })
+  end
+
+  def index_node_restricted?
+    index_node && (index_node.restricted? || index_node.ancestors.detect { |n| n.restricted? })
+  end
+end

data/app/models/redirect.rb

@@ -0,0 +1,16 @@
+class Redirect < ActiveRecord::Base
+  validates_presence_of :path, :target
+  validates_length_of :path, :minimum => 2
+  validates_uniqueness_of :path
+
+  validates_format_of :path,
+                      :with => /^\/(.*?)/,
+                      :message => I18n.t(:bad_redirect_format, :scope => [:app, :validators])
+
+  before_save :remove_trailing_slash
+
+protected
+  def remove_trailing_slash
+    path.chop! if path[-1,1] == '/'
+  end
+end

data/app/models/section.rb

@@ -0,0 +1,30 @@
+class Section < Item
+  key :page_template_id, ObjectId
+
+  tankit Porthos.config.tanking.index_name do
+    indexes :title
+    indexes :uri
+    indexes :tag_names
+    indexes :data
+  end
+
+  belongs_to :page_template
+
+  acts_as_uri :title,
+              :target => :uri,
+              :only_when_blank => true,
+              :scope => :page_template_id
+
+  delegate :template,
+           :to => :page_template
+
+  class << self
+    def from_template(template, attributes = {})
+      self.new(attributes.merge(:page_template_id => template.id))
+    end
+  end
+
+  def can_have_a_node?
+    false
+  end
+end

data/app/models/setting.rb

@@ -0,0 +1,4 @@
+class Setting < ActiveRecord::Base
+  belongs_to :settingable, :polymorphic => true
+  
+end

data/app/models/site_setting.rb

@@ -0,0 +1,11 @@
+class SiteSetting
+  include MongoMapper::Document
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  class << self
+    def value_for(setting_name)
+      SiteSetting.find_or_create_by_name(setting_name.to_s).value
+    end
+  end
+end

data/app/models/template.rb

@@ -0,0 +1,25 @@
+class Template
+  include MongoMapper::Document
+
+  key :label, String
+  key :description, String
+  key :position, Integer
+
+  many :datum_templates, :order => 'position asc' do
+    def [](handle)
+      detect { |d| d.handle == handle.to_s }
+    end
+  end
+
+  before_save :sort_datum_templates
+
+  validates_presence_of :label
+  validates_uniqueness_of :label, :case_sensitive => false
+
+protected
+
+  def sort_datum_templates
+    self.datum_templates.sort_by!(&:position)
+  end
+
+end

data/app/models/templates/content_template.rb

@@ -0,0 +1,101 @@
+class ContentTemplate < Template
+  key :template_name, String
+  after_destroy :propagate_removal_to_items
+  before_save :propagate
+
+  class_attribute :datum_template_classes
+  self.datum_template_classes = [
+    { type: 'FieldTemplate', attrs: { input_type: 'string' }},
+    { type: 'FieldTemplate', attrs: { input_type: 'boolean' }},
+    { type: 'FieldTemplate', attrs: { input_type: 'date' }},
+    { type: 'LinkFieldTemplate' },
+    { type: 'AssetAssociationTemplate' },
+    { type: 'PageAssociationTemplate' },
+  ]
+
+  def template
+    @template ||= template_name.present? ? FieldSetFileTemplate.new(template_name) : FieldSetFileTemplate.default
+  end
+
+  def to_datum(attrs = {})
+    FieldSet.new(attrs).tap do |field_set|
+      field_set.attributes = self.shared_attributes
+      field_set.data = self.datum_templates.map { |t| t.to_datum }
+    end
+  end
+
+  def shared_attributes
+    { label: self.label, content_template_id: self.id, template_name: self.template_name }
+  end
+
+  def concerned_items
+    Item.where('$or' => [
+      { 'data.content_template_id' => self.id },
+      { 'data.data.content_template_id' => self.id }
+    ])
+  end
+
+  # Finds and returns all datums matching self in field sets connected to the content template
+  # TODO: Move this to the item class
+  def find_matching_field_sets_in_item(item)
+    root_field_sets = item.data.find_all do |d|
+      d['content_template_id'] && d.content_template_id == self.id
+    end
+
+    datum_collection_field_sets = item.data.find_all do |d|
+      d.is_a?(DatumCollection) && d.content_templates_ids.include?(self.id)
+    end.map do |datum_collection|
+      datum_collection.data.find_all do |d|
+        d['content_template_id'] && d.content_template_id == self.id
+      end
+    end.flatten.compact
+    root_field_sets + datum_collection_field_sets
+  end
+
+private
+
+  def propagate
+    propagate_updates unless new?
+  end
+
+  # TODO: Add delayed job
+  def propagate_updates
+    PageTemplate.collection.update({
+      'datum_templates' => {
+        '$elemMatch' => { 'content_template_id' => self.id }
+      }
+    }, {
+      '$set' => {
+        'datum_templates.$.template_name' => self.template_name
+      }
+    }, safe: true, multiple: true)
+
+    concerned_items.each do |item|
+      find_matching_field_sets_in_item(item).each do |field_set|
+        field_set.label  = self.label
+        field_set.template_name = self.template_name
+      end
+      item.save
+    end
+  end
+
+  # TODO: Add delayed job
+  def propagate_removal_to_items
+    # Pull all field sets in pages connected to this
+    Item.pull({}, data: { 'content_template_id' => self.id })
+
+    # Pull all field sets in content blocks connected to this
+    Item.collection.update({
+      'data' => {
+        '$elemMatch' => { 'data.content_template_id' => self.id }
+      }
+    }, {
+      '$pull' => {
+        'data.$.data' => { 'content_template_id' => self.id }
+      }
+    }, multiple: true)
+
+    PageTemplate.pull({}, datum_templates: { 'content_template_id' => self.id })
+  end
+
+end