locomotivecms 3.0.0.pre.alpha

data/app/models/locomotive/content_entry.rb

@@ -0,0 +1,155 @@
+module Locomotive
+  class ContentEntry
+
+    include Locomotive::Mongoid::Document
+
+    ## extensions ##
+    include ::CustomFields::Target
+    include Concerns::Shared::Seo
+    include Concerns::Shared::Userstamp
+    include Concerns::ContentEntry::Slug
+    include Concerns::ContentEntry::Csv
+    include Concerns::ContentEntry::Localized
+    include Concerns::ContentEntry::Counter
+    include Concerns::ContentEntry::NextPrevious
+    include Concerns::ContentEntry::Notifications
+
+    ## fields ##
+    field :_slug,             localize: true
+    field :_label_field_name
+    field :_position,         type: Integer, default: 0
+    field :_visible,          type: Boolean, default: true
+
+    ## validations ##
+    validates_presence_of     :_slug
+    validates_uniqueness_of   :_slug, scope: :content_type_id, allow_blank: true
+
+    ## associations ##
+    belongs_to  :site,          class_name: 'Locomotive::Site', validate: false, autosave: false
+    belongs_to  :content_type,  class_name: 'Locomotive::ContentType', inverse_of: :entries, custom_fields_parent_klass: true
+
+    ## callbacks ##
+    before_save       :set_site
+    before_save       :set_visibility
+    before_save       :set_label_field_name
+    before_create     :add_to_list_bottom
+
+    ## named scopes ##
+    scope :visible, -> { where(_visible: true) }
+    scope :latest_updated, -> { order_by(updated_at: :desc).limit(Locomotive.config.ui[:latest_entries_nb]) }
+    scope :next_or_previous,
+      ->(condition, order_by) { where({ _visible: true }.merge(condition)).limit(1).order_by(order_by) }
+    scope :by_id_or_slug, ->(id_or_slug) { all.or({ _id: id_or_slug }, { _slug: id_or_slug }) }
+    scope :by_ids_or_slugs, ->(ids_or_slugs) { all.any_of({ :_slug.in => [*ids_or_slugs] }, { :_id.in => [*ids_or_slugs] }) }
+
+    ## indexes ##
+    index site_id: 1
+    index _type: 1
+    index content_type_id: 1
+    Locomotive.config.site_locales.each do |locale|
+      index _type: 1, "_slug.#{locale}" => 1
+      index content_type_id: 1, "_slug.#{locale}" => 1
+    end
+    index content_type_id: 1, created_at: 1
+    index content_type_id: 1, _type: 1, created_at: 1
+    index _type: 1, _position: 1
+    index content_type_id: 1, _position: 1
+
+    ## methods ##
+
+    alias :visible? :_visible?
+    alias :_permalink :_slug
+    alias :_permalink= :_slug=
+
+    # Any content entry owns a label property which is used in the back-office UI
+    # to represent it. The field used as the label is defined within the parent content type.
+    #
+    # @param [ Object ] (optional) The content type to avoid to run another MongoDB and useless query.
+    #
+    # @return [ String ] The "label" of the content entry
+    #
+    def _label(type = nil)
+      value = if self._label_field_name
+        self.send(self._label_field_name.to_sym)
+      else
+        self.send((type || self.content_type).label_field_name.to_sym)
+      end
+
+      value.respond_to?(:to_label) ? value.to_label : value.to_s
+    end
+
+    alias :to_label :_label
+
+    def as_json(*args)
+      super.tap { |json| json['_label'] = _label }
+    end
+
+    # Find a content entry by its permalink
+    #
+    # @param [ String ] The permalink
+    #
+    # @return [ Object ] The content entry matching the permalink or nil if not found
+    #
+    def self.find_by_permalink(permalink)
+      self.where(_slug: permalink).first
+    end
+
+    # Find a content entry by its permalink or its id
+    #
+    # @param [ String ] The id_or_permalink Permalink (slug) or id
+    #
+    # @return [ Object ] The content entry matching the permalink/_id or nil if not found
+    #
+    def self.find_by_id_or_permalink(id_or_permalink)
+        any_of({ _id: id_or_permalink }, { _slug: id_or_permalink }).first
+      end
+
+    # Sort the content entries from an ordered array of content entry ids.
+    # Their new positions are persisted.
+    #
+    # @param [ Array ] content_type The content type describing the entries
+    # @param [ Array ] The ordered array of ids
+    #
+    def self.sort_entries!(ids, column = :_position)
+      list = self.any_in(_id: ids.map { |id| BSON::ObjectId.from_string(id.to_s) }).to_a
+      ids.each_with_index do |id, position|
+        if entry = list.detect { |e| e._id.to_s == id.to_s }
+          entry.set column => position
+        end
+      end
+    end
+
+    # All the content entries no matter the content type they belong to
+    # share the same liquid drop class.
+    #
+    # @param [ Class ] The liquid drop class
+    #
+    def self.drop_class
+      Locomotive::Liquid::Drops::ContentEntry
+    end
+
+    protected
+
+    def set_site
+      self.site ||= self.content_type.site
+    end
+
+    def set_visibility
+      if self.respond_to?(:visible)
+        self.visible  = true if self.visible.nil?
+        self._visible = self.visible
+        return
+      end
+    end
+
+    def set_label_field_name
+      self._label_field_name = self.content_type.label_field_name
+    end
+
+    def add_to_list_bottom
+      max = self.class.indexed_max(:_position)
+      self._position = max + 1 if max
+    end
+
+  end
+end

data/app/models/locomotive/content_type.rb

@@ -0,0 +1,132 @@
+module Locomotive
+  class ContentType
+
+    include Locomotive::Mongoid::Document
+
+    ## extensions ##
+    include ::CustomFields::Source
+    include Concerns::ContentType::Label
+    include Concerns::ContentType::DefaultValues
+    include Concerns::ContentType::ItemTemplate
+    include Concerns::ContentType::Sync
+    include Concerns::ContentType::GroupBy
+    include Concerns::ContentType::OrderBy
+    include Concerns::ContentType::ClassHelpers
+
+    ## fields ##
+    field :name
+    field :description
+    field :slug
+    field :label_field_id,              type: BSON::ObjectId
+    field :label_field_name
+    field :group_by_field_id,           type: BSON::ObjectId
+    field :order_by # either a BSON::ObjectId (field id) or a String (:_position, ...etc)
+    field :order_direction,             default: 'asc'
+    field :public_submission_enabled,   type: Boolean, default: false
+    field :public_submission_accounts,  type: Array
+    field :filter_fields,               type: Array
+    field :number_of_entries
+
+    ## associations ##
+    belongs_to  :site,      class_name: 'Locomotive::Site', validate: false
+    has_many    :entries,   class_name: 'Locomotive::ContentEntry', dependent: :destroy
+
+    ## named scopes ##
+    scope :ordered, -> { order_by(updated_at: :desc) }
+    scope :by_id_or_slug, ->(id_or_slug) {
+      any_of({ _id: id_or_slug }, { slug: id_or_slug })
+    }
+
+    ## indexes ##
+    index site_id: 1, slug: 1
+
+    ## callbacks ##
+    before_validation   :normalize_slug
+    before_validation   :sanitize_public_submission_accounts
+    before_validation   :sanitize_filter_fields
+    after_validation    :bubble_fields_errors_up
+
+    ## validations ##
+    validates_presence_of   :site, :name, :slug
+    validates_uniqueness_of :slug, scope: :site_id
+    validates_size_of       :entries_custom_fields, minimum: 1, message: :too_few_custom_fields
+
+    ## behaviours ##
+    custom_fields_for :entries
+
+    ## methods ##
+
+    # Order the list of entries, paginate it if requested
+    # and filter it.
+    #
+    # @param [ Hash ] options Options to filter (where key), order (order_by key) and paginate (page, per_page keys)
+    #
+    # @return [ Criteria ] A Mongoid criteria if not paginated (array otherwise).
+    #
+    def ordered_entries(options = nil)
+      options ||= {}
+
+      # pagination
+      page, per_page = options.delete(:page), options.delete(:per_page)
+
+      # order list
+      _order_by_definition = (options || {}).delete(:order_by).try(:split) || self.order_by_definition
+
+      # get list
+      _entries = self.entries.order_by([_order_by_definition]).where(options[:where] || {})
+
+      # pagination or full list
+      !self.order_manually? && page ? _entries.page(page).per(per_page) : _entries
+    end
+
+    # Find a custom field describing an entry based on its id
+    # in first or its name if not found.
+    #
+    # @param [ String ] id_or_name The id of name of the field
+    #
+    # @return [ Object ] The custom field or nit if not found
+    #
+    def find_entries_custom_field(id_or_name)
+      return nil if id_or_name.nil? # bypass the memoization
+
+      _field = self.entries_custom_fields.find(id_or_name) rescue nil
+      _field || self.entries_custom_fields.where(name: id_or_name).first
+    end
+
+    protected
+
+    def normalize_slug
+      self.slug = self.name.clone if self.slug.blank? && self.name.present?
+      self.slug.permalink!(true) if self.slug.present?
+    end
+
+    # We do not want to have a blank value in the list of accounts.
+    def sanitize_public_submission_accounts
+      if self.public_submission_accounts
+        self.public_submission_accounts.reject! { |id| id.blank? }
+      end
+    end
+
+    # We do not want to have a blank value in the list of fields used to filter the entries.
+    def sanitize_filter_fields
+      if self.filter_fields
+        self.filter_fields.reject! { |id| id.blank? }
+      end
+    end
+
+    def bubble_fields_errors_up
+      return if self.errors[:entries_custom_fields].empty?
+
+      hash = { base: self.errors[:entries_custom_fields] }
+
+      self.entries_custom_fields.each do |field|
+        next if field.valid?
+        key = field.persisted? ? field._id.to_s : field.position.to_i
+        hash[key] = field.errors.to_a
+      end
+
+      self.errors.set(:entries_custom_fields, hash)
+    end
+
+  end
+end

data/app/models/locomotive/editable_control.rb

@@ -0,0 +1,52 @@
+module Locomotive
+  class EditableControl < EditableElement
+
+    ## fields ##
+    field :content
+    field :options, type: Array, default: []
+
+    ## methods ##
+
+    def options=(value)
+      if value.respond_to?(:split)
+        value = value.split(/\s*\,\s*/).map do |option|
+          first, last = *option.split(/\s*=\s*/)
+          last ||= first
+          { 'value' => first, 'text' => last }
+        end
+      end
+
+      super(value)
+    end
+
+    # def default_content?
+    #   false
+    # end
+
+    # def copy_attributes_from(el)
+    #   super(el)
+
+    #   %w(content options).each do |meth|
+    #     self.attributes[meth] = el.attributes[meth]
+    #   end
+    # end
+
+    # protected
+
+    # def propagate_content
+    #   if self.content_changed?
+    #     operations  = {
+    #       '$set' => {
+    #         'editable_elements.$.content' => self.content,
+    #         'editable_elements.$.options' => self.options,
+    #       }
+    #     }
+
+    #     self.page.collection.find(self._selector).update(operations, multi: true)
+    #   end
+    #   true
+    # end
+
+  end
+end
+

data/app/models/locomotive/editable_element.rb

@@ -0,0 +1,151 @@
+module Locomotive
+  class EditableElement
+
+    include Locomotive::Mongoid::Document
+
+    ## fields ##
+    field :slug
+    field :block
+    field :content,     localize: true
+    field :hint
+    field :priority,    type: Integer, default: 0
+    field :fixed,       type: Boolean, default: false
+    field :disabled,    type: Boolean, default: false, localize: true
+    field :from_parent, type: Boolean, default: false
+    field :locales,     type: Array,   default: []
+
+    ## associations ##
+    embedded_in :page, class_name: 'Locomotive::Page', inverse_of: :editable_elements
+
+    ## validations ##
+    validates_presence_of :slug
+
+    ## callbacks ##
+    # after_save :propagate_content, if: :fixed?
+
+    ## scopes ##
+    scope :by_priority,         -> { order_by(priority: :desc) }
+    scope :by_block_and_slug,   ->(block, slug) { where(block: block, slug: slug) }
+
+    ## methods ##
+
+    def disabled?
+      !!self.disabled # the original method does not work quite well with the localization
+    end
+
+    def _type
+      nil
+    end
+
+    # def disabled_in_all_translations?
+    #   return self.disabled_translations if self.disabled_translations.is_a?(Boolean)
+    #   return false if disabled_translations.blank?
+    #   self.disabled_translations.all? { |_, v| v == true }
+    # end
+
+    # # Determines if the current element can be edited in the back-office
+    # #
+    # def editable?
+    #   !self.disabled? &&
+    #   self.locales.include?(::Mongoid::Fields::I18n.locale.to_s) &&
+    #   (!self.fixed? || !self.from_parent?) &&
+    #   !self.destroyed?
+    # end
+
+    # def _run_rearrange_callbacks
+    #   # callback from page/tree. not needed in the editable elements
+    # end
+
+    # def default_content?
+    #   # needs to be overridden for each kind of elements
+    #   true
+    # end
+
+    # # Copy attributes extracted from the corresponding Liquid tag
+    # # Each editable element overrides this method.
+    # #
+    # # @param [ Hash ] attributes The up-to-date attributes
+    # #
+    # def copy_attributes(attributes)
+    #   # _type is among the mass-assign protected attributes.
+    #   if type = attributes.delete(:_type)
+    #     self._type = type
+    #   end
+
+    #   self.attributes = attributes
+    # end
+
+    # # Copy attributes from an existing editable element coming
+    # # from the parent page. Each type of an editable element may or not
+    # # override this method. The source element is a new record.
+    # #
+    # # @param [ EditableElement] el The source element
+    # #
+    # def copy_attributes_from(el)
+    #   self.attributes   = el.attributes.reject { |attr| !%w(slug block hint priority fixed disabled locales from_parent).include?(attr) }
+    #   self.from_parent  = true
+    # end
+
+    # # Copy the default attributes: _type, hint, fixed, priority and locales
+    # # from an existing editable element coming from the parent page.
+    # # Each type of an editable element may or not override this method for
+    # # options for instance.
+    # #
+    # # @param [ EditableElement] el The source element
+    # #
+    # def copy_default_attributes_from(el)
+    #   # only the type, hint and fixed properties can be modified from the element
+    #   %w(_type hint fixed priority locales).each do |attr|
+    #     self.send(:"#{attr}=", el.send(attr.to_sym))
+    #   end
+    # end
+
+    # # Set the default content from an existing editable element coming
+    # # from the parent page. Each editable element may or not
+    # # override this method. The source element is an existing record.
+    # def set_default_content_from(el)
+    #   self.add_current_locale
+    # end
+
+    # Make sure the current locale is added to the list
+    # of locales for the current element so that we know
+    # in which languages the element was translated.
+    #
+    def add_current_locale
+      locale = ::Mongoid::Fields::I18n.locale.to_s
+      self.locales << locale unless self.locales.include?(locale)
+    end
+
+    # # Set the content of the editable element with a default value
+    # # only if the content has not already been modified by the user.
+    # #
+    # # @param [ String ] content The default content.
+    # #
+    # def content_from_default=(content)
+    #   # needs to be overridden for each kind of elements
+    # end
+
+    # protected
+
+    # def _selector
+    #   locale = ::Mongoid::Fields::I18n.locale
+    #   {
+    #     'site_id'                         => self.page.site_id,
+    #     "template_dependencies.#{locale}" => { '$in' => [self.page._id] },
+    #     'editable_elements.fixed'         => true,
+    #     'editable_elements.block'         => self.block,
+    #     'editable_elements.slug'          => self.slug,
+    #   }
+    # end
+
+    # # Update the value (or content) of the elements matching the same block/slug
+    # # as the current element in all the pages inheriting from the current page.
+    # # This method is called only if the element has the "fixed" property set to true.
+    # # It also needs to be overridden for each kind of elements (file, short text, ...etc)
+    # #
+    # def propagate_content
+    #   true
+    # end
+
+  end
+end