tribeca_cms 0.1.1

data/app/models/locomotive/account.rb

@@ -0,0 +1,117 @@
+module Locomotive
+  class Account
+
+    include Locomotive::Mongoid::Document
+
+    devise *Locomotive.config.devise_modules
+
+    ## devise fields (need to be declared since 2.x) ##
+    field :remember_created_at,     :type => Time
+    field :email,                   :type => String, :null => false
+    field :encrypted_password,      :type => String, :null => false
+    field :authentication_token,    :type => String
+    field :reset_password_token,    :type => String
+    field :reset_password_sent_at,  :type => Time
+    field :password_salt,           :type => String
+    field :sign_in_count,           :type => Integer
+    field :current_sign_in_at,      :type => Time
+    field :last_sign_in_at,         :type => Time
+    field :current_sign_in_ip,      :type => String
+    field :last_sign_in_ip,         :type => String
+
+    ## attributes ##
+    field :name
+    field :locale, :default => Locomotive.config.default_locale.to_s or 'en'
+
+    ## validations ##
+    validates_presence_of :name
+
+    ## associations ##
+
+    ## callbacks ##
+    before_destroy :remove_memberships!
+
+    ## methods ##
+
+    def sites
+      @sites ||= Site.where('memberships.account_id' => self._id)
+    end
+
+    # Tell if the account has admin privileges or not.
+    # Actually, an account is considered as an admin if
+    # it owns at least one admin membership in all its sites.
+    #
+    # @return [ Boolean ] True if admin
+    #
+    def admin?
+      Site.where(:memberships => { '$elemMatch' => { :account_id => self._id, :role => :admin } }).count > 0
+    end
+
+    # Create the API token which will be passed to all the requests to the Locomotive API.
+    # It requires the credentials of an account with admin role.
+    # If an error occurs (invalid account, ...etc), this method raises an exception that has
+    # to be caught somewhere.
+    #
+    # @param [ Site ] site The site where the authentication request is made
+    # @param [ String ] email The email of the account
+    # @param [ String ] password The password of the account
+    #
+    # @return [ String ] The API token
+    #
+    def self.create_api_token(site, email, password)
+      raise 'The request must contain the user email and password.' if email.blank? or password.blank?
+
+      account = self.where(:email => email.downcase).first
+
+      raise 'Invalid email or password.' if account.nil?
+
+      account.ensure_authentication_token!
+
+      if not account.valid_password?(password) # TODO: check admin roles
+        raise 'Invalid email or password.'
+      end
+
+      account.authentication_token
+    end
+
+    # Logout the user responding to the token passed in parameter from the API.
+    # An exception is raised if no account corresponds to the token.
+    #
+    # @param [ String ] token The API token created by the create_api_token method.
+    #
+    # @return [ String ] The API token
+    #
+    def self.invalidate_api_token(token)
+      account = self.where(:authentication_token => token).first
+
+      raise 'Invalid token.' if account.nil?
+
+      account.reset_authentication_token!
+
+      token
+    end
+
+    def devise_mailer
+      Locomotive::DeviseMailer
+    end
+
+    protected
+
+    def password_required?
+      !persisted? || !password.blank? || !password_confirmation.blank?
+    end
+
+    def remove_memberships!
+      self.sites.each do |site|
+        membership = site.memberships.where(:account_id => self._id).first
+
+        if site.admin_memberships.size == 1 && membership.admin?
+          raise ::I18n.t('errors.messages.needs_admin_account')
+        else
+          membership.destroy
+        end
+      end
+    end
+
+  end
+end

data/app/models/locomotive/content_asset.rb

@@ -0,0 +1,40 @@
+module Locomotive
+  class ContentAsset
+
+    include Locomotive::Mongoid::Document
+
+    ## extensions ##
+    include Extensions::Asset::Types
+    include Extensions::Asset::Vignette
+
+    ## fields ##
+    field :content_type,  :type => String
+    field :width,         :type => Integer
+    field :height,        :type => Integer
+    field :size,          :type => Integer
+    field :position,      :type => Integer, :default => 0
+
+    ## associations ##
+    belongs_to :site, :class_name => 'Locomotive::Site'
+
+    ## validations ##
+    validates_presence_of :source
+
+    ## behaviours ##
+    mount_uploader :source, ContentAssetUploader, :mount_on => :source_filename
+
+    ## methods ##
+
+    alias :name :source_filename
+
+    def extname
+      return nil unless self.source?
+      File.extname(self.source_filename).gsub(/^\./, '')
+    end
+
+    def to_liquid
+      { :url => self.source.url }.merge(self.attributes).stringify_keys
+    end
+
+  end
+end

data/app/models/locomotive/content_entry.rb

@@ -0,0 +1,197 @@
+module Locomotive
+  class ContentEntry
+
+    include Locomotive::Mongoid::Document
+
+    ## extensions ##
+    include ::CustomFields::Target
+    include Extensions::Shared::Seo
+
+    ## fields ##
+    field :_slug
+    field :_label_field_name
+    field :_position,         :type => Integer, :default => 0
+    field :_visible,          :type => Boolean, :default => true
+
+    ## validations ##
+    validates :_slug, :presence => true, :uniqueness => { :scope => :content_type_id }
+
+    ## associations ##
+    belongs_to  :site,          :class_name => 'Locomotive::Site'
+    belongs_to  :content_type,  :class_name => 'Locomotive::ContentType', :inverse_of => :entries
+
+    ## callbacks ##
+    before_validation :set_slug
+    before_save       :set_site
+    before_save       :set_visibility
+    before_save       :set_label_field_name
+    before_create     :add_to_list_bottom
+    after_create      :send_notifications
+
+    ## named scopes ##
+    scope :visible, :where => { :_visible => true }
+    scope :latest_updated, :order_by => :updated_at.desc, :limit => Locomotive.config.ui[:latest_entries_nb]
+
+    ## 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
+
+    # Tell if the content entry has been translated or not.
+    # It just checks if the field used for the label has been translated.
+    #
+    # @return [ Boolean ] True if translated, false otherwise
+    #
+    def translated?
+      if self.respond_to?(:"#{self._label_field_name}_translations")
+        self.send(:"#{self._label_field_name}_translations").key?(::Mongoid::Fields::I18n.locale.to_s) #rescue false
+      else
+        true
+      end
+    end
+
+    # Return the locales the content entry has been translated to.
+    #
+    # @return [ Array ] The list of locales. Nil if not localized
+    #
+    def translated_in
+      if self.respond_to?(:"#{self._label_field_name}_translations")
+        self.send(:"#{self._label_field_name}_translations").keys
+      else
+        nil
+      end
+    end
+
+    # Return the next content entry based on the order defined in the parent content type.
+    #
+    # @param [ Object ] The next content entry or nil if not found
+    #
+    def next
+      next_or_previous :gt
+    end
+
+    # Return the previous content entry based on the order defined in the parent content type.
+    #
+    # @param [ Object ] The previous content entry or nil if not found
+    #
+    def previous
+      next_or_previous :lt
+    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
+
+    # Sort the content entries from an ordered array of content entry ids.
+    # Their new positions are persisted.
+    #
+    # @param [ Array ] The ordered array of ids
+    #
+    def self.sort_entries!(ids)
+      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.update_attributes :_position => position
+        end
+      end
+    end
+
+    protected
+
+    # Retrieve the next or the previous entry following the order
+    # defined in the parent content type.
+    #
+    # @param [ Symbol ] :gt for the next element, :lt for the previous element
+    #
+    # @return [ Object ] The next or previous content entry or nil if none
+    #
+    def next_or_previous(matcher = :gt)
+      order_by  = self.content_type.order_by_definition(matcher == :lt)
+      criterion = self.content_type.order_by_attribute.to_sym.send(matcher)
+      value     = self.send(self.content_type.order_by_attribute.to_sym)
+
+      self.class.where(criterion => value).order_by([order_by]).limit(1).first
+    end
+
+    # Sets the slug of the instance by using the value of the highlighted field
+    # (if available). If a sibling content instance has the same permalink then a
+    # unique one will be generated
+    def set_slug
+      self._slug = self._label.dup if self._slug.blank? && self._label.present?
+
+      if self._slug.present?
+        self._slug.permalink!
+        self._slug = self.next_unique_slug if self.slug_already_taken?
+      end
+    end
+
+    # Return the next available unique slug as a string
+    def next_unique_slug
+      slug        = self._slug.gsub(/-\d*$/, '')
+      last_slug   = self.class.where(:_id.ne => self._id, :_slug => /^#{slug}-?\d*?$/i).order_by(:_slug).last._slug
+      next_number = last_slug.scan(/-(\d)$/).flatten.first.to_i + 1
+      [slug, next_number].join('-')
+    end
+
+    def slug_already_taken?
+      self.class.where(:_id.ne => self._id, :_slug => self._slug).any?
+    end
+
+    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
+      self._position = self.class.max(:_position).to_i + 1
+    end
+
+    def send_notifications
+      return if !self.content_type.public_submission_enabled? || self.content_type.public_submission_accounts.blank?
+
+      self.site.accounts.each do |account|
+        next unless self.content_type.public_submission_accounts.map(&:to_s).include?(account._id.to_s)
+
+        Locomotive::Notifications.new_content_entry(account, self).deliver
+      end
+    end
+
+  end
+end

data/app/models/locomotive/content_type.rb

@@ -0,0 +1,224 @@
+module Locomotive
+  class ContentType
+
+    include Locomotive::Mongoid::Document
+
+    ## extensions ##
+    include CustomFields::Source
+    include Extensions::ContentType::DefaultValues
+    include Extensions::ContentType::ItemTemplate
+    include Extensions::ContentType::Sync
+
+    ## 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
+    field :order_direction,             :default => 'asc'
+    field :public_submission_enabled,   :type => Boolean, :default => false
+    field :public_submission_accounts,  :type => Array
+
+    ## associations ##
+    belongs_to  :site,      :class_name => 'Locomotive::Site'
+    has_many    :entries,   :class_name => 'Locomotive::ContentEntry', :dependent => :destroy
+
+    ## named scopes ##
+    scope :ordered, :order_by => :updated_at.desc
+
+    ## indexes ##
+    index [[:site_id, Mongo::ASCENDING], [:slug, Mongo::ASCENDING]]
+
+    ## callbacks ##
+    before_validation   :normalize_slug
+    before_validation   :sanitize_public_submission_accounts
+    after_validation    :bubble_fields_errors_up
+    before_update       :update_label_field_name_in_entries
+
+    ## 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 ##
+
+    def order_manually?
+      self.order_by == '_position'
+    end
+
+    def order_by_definition(reverse_order = false)
+      direction = self.order_manually? ? 'asc' : self.order_direction || 'asc'
+
+      if reverse_order
+        direction = (direction == 'asc' ? 'desc' : 'asc')
+      end
+
+      [order_by_attribute, direction]
+    end
+
+    def ordered_entries(conditions = {})
+      _order_by_definition = (conditions || {}).delete(:order_by).try(:split) || self.order_by_definition
+      self.entries.order_by([_order_by_definition]).where(conditions)
+    end
+
+    def groupable?
+      !!self.group_by_field && %w(select belongs_to).include?(group_by_field.type)
+    end
+
+    def group_by_field
+      self.find_entries_custom_field(self.group_by_field_id)
+    end
+
+    def list_or_group_entries
+      if self.groupable?
+        if group_by_field.type == 'select'
+          self.entries.group_by_select_option(self.group_by_field.name, self.order_by_definition)
+        else
+          group_by_belongs_to_field(self.group_by_field)
+        end
+      else
+        self.ordered_entries
+      end
+    end
+
+    def class_name_to_content_type(class_name)
+      self.class.class_name_to_content_type(class_name, self.site)
+    end
+
+    def label_field_id=(value)
+      # update the label_field_name if the label_field_id is changed
+      new_label_field_name = self.entries_custom_fields.where(:_id => value).first.try(:name)
+      self.label_field_name = new_label_field_name
+      super(value)
+    end
+
+    def label_field_name=(value)
+      # mandatory if we allow the API to set the label field name without an id of the field
+      @new_label_field_name = value unless value.blank?
+      super(value)
+    end
+
+    # Get the class name of the entries.
+    #
+    # @return [ String ] The class name of all the entries
+    #
+    def entries_class_name
+      self.klass_with_custom_fields(:entries).to_s
+    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
+
+    # Retrieve from a class name the associated content type within the scope of a site.
+    # If no content type is found, the method returns nil
+    #
+    # @param [ String ] class_name The class name
+    # @param [ Locomotive::Site ] site The Locomotive site
+    #
+    # @return [ Locomotive::ContentType ] The content type matching the class_name
+    #
+    def self.class_name_to_content_type(class_name, site)
+      if class_name =~ /^Locomotive::Entry(.*)/
+        site.content_types.find($1)
+      else
+        nil
+      end
+    end
+
+    protected
+
+    def group_by_belongs_to_field(field)
+      grouped_entries     = self.ordered_entries.group_by(&:"#{field.name}_id")
+      columns             = grouped_entries.keys
+      target_content_type = self.class_name_to_content_type(field.class_name)
+      all_columns         = target_content_type.ordered_entries
+
+      all_columns.map do |column|
+        if columns.include?(column._id)
+          {
+            :name     => column._label(target_content_type),
+            :entries  => grouped_entries.delete(column._id)
+          }
+        else
+          nil
+        end
+      end.compact.tap do |groups|
+        unless grouped_entries.empty? # "orphans" ?
+          groups << { :name => nil, :entries => grouped_entries.values.flatten }
+        end
+      end
+    end
+
+    def order_by_attribute
+      return self.order_by if %w(created_at updated_at _position).include?(self.order_by)
+      self.entries_custom_fields.find(self.order_by).name rescue 'created_at'
+    end
+
+    def normalize_slug
+      self.slug = self.name.clone if self.slug.blank? && self.name.present?
+      self.slug.permalink! 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
+
+    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
+
+    def update_label_field_name_in_entries
+      self.klass_with_custom_fields(:entries).update_all :_label_field_name => self.label_field_name
+    end
+
+    # Makes sure the class_name filled in a belongs_to or has_many field
+    # does not belong to another site. Adds an error if it presents a
+    # security problem.
+    #
+    # @param [ CustomFields::Field ] field The field to check
+    #
+    def ensure_class_name_security(field)
+      if field.class_name =~ /^Locomotive::Entry([a-z0-9]+)$/
+        content_type = Locomotive::ContentType.find($1)
+
+        if content_type.site_id != self.site_id
+          field.errors.add :class_name, :security
+        end
+      else
+        # for now, does not allow external classes
+        field.errors.add :class_name, :security
+      end
+    end
+
+  end
+end
+