locomotivecms_mounter_pull_19 1.5.4

data/lib/locomotive/mounter/models/content_field.rb

@@ -0,0 +1,190 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentField < Base
+
+        ## fields ##
+        field :label
+        field :name
+        field :type,       default: :string
+        field :hint
+        field :position,   default: 0
+        field :required,   default: false
+        field :unique,     default: false
+        field :localized,  default: false
+        field :searchable, default: false
+
+        # text
+        field :text_formatting
+
+        # select
+        field :select_options, type: :array, class_name: 'Locomotive::Mounter::Models::ContentSelectOption'
+
+        # relationships: belongs_to, has_many, many_to_many
+        field :class_slug # out
+        field :class_name # in
+        field :inverse_of
+        field :order_by
+        field :ui_enabled
+
+        alias :target :class_name
+        alias :target= :class_name=
+        alias :raw_select_options= :select_options=
+
+        ## callbacks ##
+        set_callback :initialize, :after, :prepare_attributes
+
+        ## other accessors ##
+        attr_accessor :_destroy
+
+        ## methods ##
+
+        def prepare_attributes
+          self.label ||= self.name.try(:humanize)
+          self.type = self.type.to_sym
+          self.sanitize
+        end
+
+        # Tell if it describes a relationship (belongs_to, many_to_many, has_many) or not.
+        #
+        # @return [ Boolean ] True if describing a relationship
+        #
+        def is_relationship?
+          %w(belongs_to has_many many_to_many).include?(self.type.to_s)
+        end
+
+        # Tell if the id, the name of the field or other property based on
+        # its name (like formatted_<date field>) matches the parameter.
+        #
+        # @param [ String / Symbol] name_or_id Name or Id of the field
+        #
+        # @return [ Boolean ] True if the current field matches the parameter
+        #
+        def matches?(id_or_name)
+          default = [self._id, self.name]
+
+          list = default + (case self.type.to_sym
+          when :date, :date_time then ["formatted_#{self.name}"]
+          else
+            []
+          end)
+
+          list.include?(id_or_name.to_s)
+        end
+
+        # Return the content type matching the class_name / target attribute
+        #
+        # @return [ Object ] The matching Content Type
+        #
+        def klass
+          (@klass ||= self.mounting_point.content_types[self.class_name]).tap do |klass|
+            if klass.nil?
+              raise UnknownContentTypeException.new("unknow content type #{self.class_name}")
+            end
+          end
+        end
+
+        # Set directly the content type matching the class_name.
+        #
+        # @param [ Object ] The matching Content Type
+        #
+        def klass=(content_type)
+          if self.class_name == content_type.slug
+            @klass = content_type
+          end
+        end
+
+        # Find a select option by its name IN the current locale.
+        #
+        # @param [ String / Symbol] name_or_id Name or Id of the option
+        #
+        # @return [ Object ] The select option or nil if not found
+        #
+        def find_select_option(name_or_id)
+          return nil if self.select_options.blank?
+          self.select_options.detect { |option| option.name.to_s == name_or_id.to_s || option._id == name_or_id }
+        end
+
+        # Return the params used for the API.
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params
+          params = self.filter_attributes %w(label name type hint position required localized unique searchable)
+
+          # we set the _id / _destroy attributes for embedded documents
+          params[:_id]      = self._id if self.persisted?
+          params[:_destroy] = self._destroy if self._destroy
+
+          case self.type
+          when :text
+            params[:text_formatting] = self.text_formatting
+          when :select
+            params[:raw_select_options] = self.select_options.map(&:to_params)
+          when :belongs_to
+            params[:class_name] = self.class_name
+          when :has_many, :many_to_many
+            %w(class_name inverse_of order_by ui_enabled).each do |name|
+              params[name.to_sym] = self.send(name.to_sym)
+            end
+          end
+
+          params
+        end
+
+        # Instead of returning a simple hash, it returns a hash with name as the key and
+        # the remaining attributes as the value.
+        #
+        # @return [ Hash ] A hash of hash
+        #
+        def to_hash
+          hash = super.delete_if { |k, v| %w(name position).include?(k) }
+
+          # class_name is chosen over class_slug
+          if self.is_relationship?
+            hash['class_name'] ||= hash['class_slug']
+            hash.delete('class_slug')
+          end
+
+          # select options
+          if self.type == :select
+            hash['select_options'] = self.select_options_to_hash
+          end
+
+          { self.name => hash }
+        end
+
+        protected
+
+        # Clean up useless properties depending on its type
+        def sanitize
+          # ui_enabled only for the belongs_to, has_many and many_to_many types
+          self.ui_enabled = nil unless self.is_relationship?
+
+          # text_formatting only for the text type
+          self.text_formatting = nil unless self.type == :text
+        end
+
+        def select_options_to_hash
+          locales = self.select_options.map { |option| option.translated_in }.flatten.uniq
+          options = self.select_options.sort { |a, b| a.position <=> b.position }
+
+          if locales.size > 1
+            {}.tap do |by_locales|
+              locales.each do |locale|
+                options.each do |option|
+                  (by_locales[locale.to_s] ||= []) << option.name_translations[locale]
+                end
+              end
+            end
+          else
+            options.map(&:name)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/content_select_option.rb

@@ -0,0 +1,29 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentSelectOption < Base
+
+        ## fields ##
+        field :name,      localized: true
+        field :position,  default: 0
+
+        ## methods ##
+
+        # Return the params used for the API.
+        #
+        # @param [ Hash ] options For now, none
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params(options = nil)
+          { name: self.name_translations, position: self.position }.tap do |params|
+            params[:id] = self._id if self.persisted?
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/models/content_type.rb

@@ -0,0 +1,274 @@
+module Locomotive
+  module Mounter
+    module Models
+
+      class ContentType < Base
+
+        ## fields ##
+        field :name
+        field :description
+        field :slug
+        field :label_field_name
+        field :group_by
+        field :order_by
+        field :order_direction
+        field :public_submission_enabled
+        field :public_submission_accounts
+        field :raw_item_template
+
+        field :fields, type: :array, class_name: 'Locomotive::Mounter::Models::ContentField'
+
+        field :entries, association: true
+
+        ## callbacks ##
+        set_callback :initialize, :after, :sanitize
+        set_callback :initialize, :after, :assign_mounting_point_to_fields
+
+        ## other accessors ##
+        attr_accessor :klass_name, :group_by_field_id
+
+        ## aliases ##
+        alias_method :group_by_field_name, :group_by
+        alias_method :group_by_field_name=, :group_by=
+
+        ## methods ##
+
+        # Return the label field (by the default the first field)
+        #
+        # @return [ Object ] The label field
+        #
+        def label_field
+          self.find_field(self.label_field_name) || self.fields.first
+        end
+
+        # Return the group_by field
+        #
+        # @return [ Object ] The group_by field
+        #
+        def group_by_field
+          self.find_field(self.group_by_field_name)
+        end
+
+        # Return the order_by field
+        #
+        # @return [ Object ] The order_by field
+        #
+        def order_by_field
+          self.find_field(self.order_by)
+        end
+
+        # Build a content entry and add it to the list of entries of the content type.
+        # The content type will be referenced into the newly built entry .
+        #
+        # @param [ Hash ] attributes Attributes of the new content entry
+        #
+        # @return [ Object ] The newly built content entry
+        #
+        def build_entry(attributes)
+          ContentEntry.new(content_type: self).tap do |entry|
+            # set the link to the mounting point
+            entry.mounting_point = self.mounting_point
+
+            # do not forget that we are manipulating dynamic fields
+            attributes.each do |k, v|
+              begin
+                field = self.find_field(k)
+
+                if field.nil? && v.is_a?(Hash) # not a dynamic field but localized (permalink ?)
+                  entry.send(:"#{k}_translations=", v)
+                elsif field.nil?
+                  entry.send(:"#{k}=", v)
+                else
+                  entry.send(:"#{field.name}=", v)
+                end
+              rescue NoMethodError => e
+                Mounter.logger.error e.backtrace
+                raise FieldDoesNotExistException.new("The '#{self.slug}' content type does not have a field named '#{k}'.")
+              end
+            end
+
+            # force the slug to be defined from its label and in all the locales
+            entry.send :set_slug
+
+            (self.entries ||= []) << entry
+          end
+        end
+
+        # Tell if the content type owns a field which defines
+        # a relationship to another content type.
+        #
+        # @return [ Boolean ] True if a relationship field exists
+        #
+        def with_relationships?
+          self.fields.any? { |field| field.is_relationship? }
+        end
+
+        # Return the list of fields which do not describe
+        # a relationship.
+        #
+        # @return [ Array ] The list of fields.
+        #
+        def non_relationship_fields
+          self.fields.select { |field| !field.is_relationship? }
+        end
+
+        # Return the list of file fields.
+        #
+        # @return [ Array ] The list of file fields.
+        #
+        def file_fields
+          self.fields.select { |field| field.type == :file }
+        end
+
+        # Find a field by its name (string or symbol) or its id (API)
+        #
+        # @param [ String / Symbol] name_or_id Name or Id of the field
+        #
+        # @return [ Object ] The field if it exists or nil
+        #
+        def find_field(name_or_id)
+          self.fields.detect { |field| field.matches?(name_or_id) }
+        end
+
+        # Find a content entry by its ids (ie: _permalink or _label)
+        #
+        # @param [ String ] id A permalink or a label
+        #
+        # @return [ Object ] The content entry if it exists or nil
+        #
+        def find_entry(id)
+          (self.entries || []).detect { |entry| [entry._permalink, entry._label].include?(id) }
+        end
+
+        # Find all the entries whose their _permalink or _label is among the ids
+        # passed in parameter.
+        #
+        # @param [ Array ] ids List of permalinks or labels
+        #
+        # @return [ Array ] List of content entries or [] if none
+        #
+        def find_entries_among(ids)
+          (self.entries || []).find_all { |entry| [*ids].any? { |v| [entry._permalink, entry._label].include?(v) } }
+        end
+
+        # Find all the entries by a field and its value.
+        #
+        # @param [ String ] name Name of the field
+        # @param [ String / Array ] value The different values of the field to test
+        #
+        # @return [ Array ] List of content entries or [] if none
+        #
+        def find_entries_by(name, value)
+          values = [*value]
+          (self.entries || []).find_all do |entry|
+            raw_value = entry.send(:localized_dynamic_attribute_value, name)
+            values.include?(raw_value)
+          end
+        end
+
+        # Return the params used for the API.
+        # The options parameter can be used to get all the fields even
+        # the ones describing a relationship with another content type.
+        #
+        # @param [ Hash ] options Default values: { all_fields: false }
+        #
+        # @return [ Hash ] The params
+        #
+        def to_params(options = nil)
+          options = { all_fields: false }.merge(options || {})
+
+          params = self.filter_attributes %w(name slug description label_field_name group_by_field_name order_by order_direction public_submission_enabled raw_item_template)
+
+          # group by
+          params[:group_by_field_name] = self.group_by_field.name if self.group_by_field
+
+          # order by
+          params[:order_by] = '_position' if self.order_by == 'manually'
+
+          # fields
+          _fields = options[:all_fields] ? self.fields : self.non_relationship_fields
+          params[:entries_custom_fields] = _fields.map(&:to_params)
+
+          params
+        end
+
+        # Return a hash with sanitized attributes. It will be used to generate
+        # the corresponding yaml file.
+        #
+        # @return [ Hash ] A hash used by the to_yaml method
+        #
+        def to_hash
+          fields = %w(name slug description label_field_name order_by order_direction public_submission_enabled public_submission_accounts raw_item_template)
+
+          _attributes = self.attributes.delete_if { |k, v| !fields.include?(k.to_s) || v.blank? }.deep_stringify_keys
+
+          # group by
+          _attributes['group_by'] = self.group_by_field.name if self.group_by_field
+
+          # order by
+          _attributes['order_by'] = self.order_by_field.name if self.order_by_field
+          _attributes['order_by'] = 'manually' if self.order_by == '_position'
+
+          # custom fields
+          _attributes['fields'] = self.fields
+
+          _attributes
+        end
+
+        def to_s
+          self.name
+        end
+
+        protected
+
+        # Give an unique slug based on a label and within the scope of the content type.
+        #
+        # @param [ String ] label The label. If nil, we take the singularized version of the content type slug.
+        #
+        # @return [ String ] An unique slug
+        #
+        def label_to_slug(label = nil)
+          label ||= self.slug.singularize
+          base, index = label.parameterize('-'), 1
+          unique_slug = base
+
+          while self.find_entry(unique_slug)
+            unique_slug = "#{base}-#{index}"
+            index += 1
+          end
+
+          unique_slug
+        end
+
+        # Method used to clean up the content and its fields.
+        # Besides, it also sets the values defined by other attributes.
+        def sanitize
+          # if no label_field_name provided, take the first field
+          unless self.label_field_name
+            self.label_field_name = (self.fields || []).first.try(:name)
+          end
+
+          # define group_by_field from group_by_field_id
+          if self.group_by_field_name.blank? && self.group_by_field_id.present?
+            self.group_by_field_name = self.find_field(self.group_by_field_id)
+          end
+
+          # public_submission_accounts means public_submission_enabled set to true
+          self.public_submission_enabled = true if self.public_submission_accounts.is_a?(Array)
+        end
+
+        # Each field should have a reference to the mounting point
+        #
+        def assign_mounting_point_to_fields
+          return if self.fields.blank?
+
+          self.fields.each do |field|
+            field.mounting_point = self.mounting_point
+          end
+        end
+
+      end
+
+    end
+  end
+end