locomotivecms 3.0.0.pre.alpha

data/app/models/locomotive/concerns/asset/types.rb

@@ -0,0 +1,36 @@
+module Locomotive
+  module Concerns
+    module Asset
+      module Types
+
+        extend ActiveSupport::Concern
+
+        included do
+          scope :by_content_type,   ->(content_type)  { content_type.blank? ? all : where(content_type: content_type.to_s) }
+          scope :by_content_types,  ->(content_types) { content_types.blank? ? all : where(:content_type.in => [*content_types]) }
+
+          all_types.each do |type|
+            scope :"only_#{type}", -> { where(content_type: type) }
+
+            define_method("#{type}?") do
+              self.content_type.to_s == type
+            end
+          end
+        end
+
+        module ClassMethods
+
+          def all_types
+            %w{image pdf media stylesheet javascript font}
+          end
+
+          def types_for_content_editing
+            all_types - %w(stylesheet javascript font)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/asset/vignette.rb

@@ -0,0 +1,35 @@
+module Locomotive
+  module Concerns
+    module Asset
+      module Vignette
+
+        def vignette_url
+          if self.image?
+            if self.width < 85 && self.height < 85
+              self.source.url
+            else
+              Locomotive::Dragonfly.resize_url(self.source, '85x85#')
+            end
+          elsif self.pdf?
+            Locomotive::Dragonfly.thumbnail_pdf(self.source, '85x85#')
+          end
+        end
+
+        def alternative_vignette_url
+          format = if self.image?
+            if self.width > self.height
+              '190x120>'
+            else
+              '190x120>'
+            end
+          elsif self.pdf?
+            '190x120#'
+          end
+
+          Locomotive::Dragonfly.thumbnail_pdf(self.source, format) if format
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/content_entry/counter.rb

@@ -0,0 +1,27 @@
+module Locomotive
+  module Concerns
+    module ContentEntry
+      module Counter
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## callbacks ##
+          after_create  :inc_number_of_entries
+          after_destroy :dec_number_of_entries
+
+        end
+
+        def inc_number_of_entries
+          self.content_type.inc(number_of_entries: 1)
+        end
+
+        def dec_number_of_entries
+          self.content_type.inc(number_of_entries: -1)
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/content_entry/csv.rb

@@ -0,0 +1,82 @@
+module Locomotive
+  module Concerns
+    module ContentEntry
+      module Csv
+
+        extend ActiveSupport::Concern
+
+        # Get the values from the custom fields as an array.
+        # Values are ordered by the position of the custom fields.
+        # It also adds the created_at value of the instance.
+        #
+        # @param [ Hash ] options For now, stores only the host for the File fields.
+        #
+        # @return [ Array ]
+        #
+        def to_values(options = {})
+          values = self.content_type.ordered_entries_custom_fields.map do |field|
+            value = self.send(field.name)
+            self.value_from_type(field.type.to_sym, value, options)
+          end.compact
+
+          values << I18n.l(self.created_at, format: :long)
+        end
+
+        protected
+
+        # Return the transformed value for a particular field type (string, text, ...etc).
+        #
+        # @param [ Symbol ] type Type of the field
+        # @param [ Object ] value Value of the field in the current instance
+        # @param [ Hash ] options For now, stores only the host for the File fields.
+        #
+        # @return [ Object ]
+        #
+        def value_from_type(type, value, options)
+          case type
+          when :file
+            value.blank? ? '' : value.guess_url(options[:host])
+          when :belongs_to
+            value.try(:_label) || ''
+          when :has_many, :many_to_many
+            value.map(&:_label).join(', ')
+          when :tags
+            [*value].join(', ')
+          else
+            value == nil ? '' : value
+          end
+        end
+
+        module ClassMethods
+
+          # Generate a csv from a collection of content entries
+          #
+          # @param [ Hash ] options Options for the csv generation
+          #
+          # @return [ String ] The well-generated CSV document
+          #
+          def to_csv(options = {})
+            content_type  = options.delete(:content_type) || all.first.try(:content_type)
+            csv_options   = options.select do |k, v|
+              CSV::DEFAULT_OPTIONS.keys.include?(k.to_sym)
+            end
+
+            fields = content_type.ordered_entries_custom_fields
+            labels = fields.map(&:label) << I18n.t('mongoid.attributes.locomotive/content_entry.created_at')
+
+            CSV.generate(csv_options) do |csv|
+              # header
+              csv << labels
+              # body
+              all.each_by(100) do |entry|
+                csv << entry.to_values(options)
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/content_entry/localized.rb

@@ -0,0 +1,80 @@
+module Locomotive
+  module Concerns
+    module ContentEntry
+      module Localized
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## fields ##
+          field :_translated, type: Boolean, localize: true
+
+          ## callbacks ##
+          before_save :persist_translated_status
+
+        end
+
+        # Tell if the content entry has been translated or not.
+        # It just checks if the field used for the label has been translated.
+        # It assumes the entry is localized.
+        #
+        # @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.localized?
+            self.send(:"#{self._label_field_name}_translations").keys
+          else
+            nil
+          end
+        end
+
+        # Tell if the field of the content entry has been translated
+        # in the current locale or not.
+        #
+        # @param [ String/Object ] field The field or the name of the field
+        #
+        # @return [ Boolean ] True if translated, false if not, nil if the field is not localized
+        #
+        def translated_field?(field_or_name)
+          field = field_or_name.respond_to?(:name) ? field_or_name : self.fields[field_or_name.to_s]
+
+          if field.try(:localized?)
+            locale = ::Mongoid::Fields::I18n.locale.to_s
+            (self.attributes[field.name] || {}).key?(locale)
+          else
+            nil
+          end
+        end
+
+        # Tell if the entry is localized or not, meaning if the label field
+        # is localized or not.
+        #
+        # @return [ Boolean ] True if localized, false otherwise
+        #
+        def localized?
+          self.respond_to?(:"#{self._label_field_name}_translations")
+        end
+
+        protected
+
+        def persist_translated_status
+          self._translated = self.translated?
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/content_entry/next_previous.rb

@@ -0,0 +1,49 @@
+module Locomotive
+  module Concerns
+    module ContentEntry
+      module NextPrevious
+
+        # 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
+
+        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)
+          # the matchers is supposed to be fine for the default direction, meaning 'asc'
+          # if the direction is not ascending, we need to reverse the matcher
+          matcher = matcher == :gt ? :lt : :gt if self.content_type.order_direction != 'asc'
+
+          attribute = self.content_type.order_by_attribute
+          direction = matcher == :gt ? 'asc' : 'desc'
+
+          criterion = attribute.to_sym.send(matcher)
+          value     = self.send(attribute.to_sym)
+          order_by  = [attribute, direction]
+
+          self.class.next_or_previous({ criterion => value }, order_by).first
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/content_entry/notifications.rb

@@ -0,0 +1,33 @@
+module Locomotive
+  module Concerns
+    module ContentEntry
+      module Notifications
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## callbacks ##
+          after_create  :send_notifications, if: :notifications?
+
+        end
+
+        def notifications?
+          self.content_type.public_submission_enabled? &&
+          !self.content_type.public_submission_accounts.blank?
+        end
+
+        def send_notifications
+          account_ids = self.content_type.public_submission_accounts.map(&:to_s)
+
+          self.site.accounts.each do |account|
+            next unless account_ids.include?(account._id.to_s)
+
+            Locomotive::Notifications.new_content_entry(account, self).deliver
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/content_entry/slug.rb

@@ -0,0 +1,86 @@
+module Locomotive
+  module Concerns
+    module ContentEntry
+      module Slug
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## callbacks ##
+          before_validation :set_slug
+
+        end
+
+        protected
+
+        # Set 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.find_next_unique_slug if self.slug_already_taken?
+          end
+
+          # all the site locales share the same slug ONLY IF the entry is not localized.
+          self.set_same_slug_for_all_site_locales if !self.localized?
+        end
+
+        # For each locale of the site, we set the slug
+        # coming from the value for the default locale.
+        def set_same_slug_for_all_site_locales
+          return unless self.set_site.localized?
+
+          default_slug = self._slug
+
+          self.set_site.locales.each do |locale|
+            ::Mongoid::Fields::I18n.with_locale(locale) do
+              self._slug = default_slug
+            end
+          end
+        end
+
+        # Find the next available unique slug as a string
+        # and replace the current _slug.
+        def find_next_unique_slug
+          _index  = 0
+          _base   = self._slug.gsub(/-\d+$/, '')
+
+          if _similar = similar_slug(_base)
+            _index = _similar.scan(/-(\d+)$/).flatten.last.to_i
+          end
+
+          loop do
+            _index += 1
+            self._slug = [_base, _index].join('-')
+            break unless self.slug_already_taken?
+          end
+        end
+
+        def similar_slug(slug)
+          _last = self.class.where(:_id.ne => self._id, _slug: /^#{slug}-?\d*$/i)
+                    .only(:_slug)
+                    .order_by(:_id.desc)
+                    .context
+                    .query
+                    .first
+
+          if _last
+            _last['_slug'][::Mongoid::Fields::I18n.locale.to_s]
+          else
+            nil
+          end
+        end
+
+        def slug_already_taken?
+          self.class.where(:_id.ne => self._id, _slug: self._slug).any?
+        end
+
+      end
+    end
+  end
+end

data/app/models/locomotive/concerns/content_type/class_helpers.rb

@@ -0,0 +1,73 @@
+module Locomotive
+  module Concerns
+    module ContentType
+      module ClassHelpers
+
+        extend ActiveSupport::Concern
+
+        def class_name_to_content_type(class_name)
+          self.class.class_name_to_content_type(class_name, self.site)
+        end
+
+        # Get the class of the entries
+        #
+        # @return [ Class ] The class of the entries
+        #
+        def entries_class
+          self.klass_with_custom_fields(:entries)
+        end
+
+        # Get the class name of the entries.
+        #
+        # @return [ String ] The class name of all the entries
+        #
+        def entries_class_name
+          self.entries_class.to_s
+        end
+
+        protected
+
+        # Make 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::ContentEntry([a-z0-9]+)$/
+            # if the content type does not exist (anymore), bypass the security checking
+            content_type = Locomotive::ContentType.find($1) rescue return
+
+            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
+
+        public module ClassMethods
+
+          # 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 class_name_to_content_type(class_name, site)
+            if class_name =~ /^Locomotive::ContentEntry(.*)/
+              site.content_types.find($1)
+            else
+              nil
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end