locomotivecms 3.0.0.pre.alpha

data/app/presenters/locomotive/snippet_presenter.rb

@@ -0,0 +1,22 @@
+module Locomotive
+  class SnippetPresenter < BasePresenter
+
+    ## properties ##
+
+    properties  :name, :slug, :template
+    property    :updated_at, only_getter: true
+
+    ## other getters / setters ##
+
+    def updated_at
+      I18n.l(self.__source.updated_at, format: :short)
+    end
+
+    ## custom as_json ##
+
+    def as_json_for_html_view
+      self.as_json(self.getters - %w(template))
+    end
+
+  end
+end

data/app/presenters/locomotive/theme_asset_presenter.rb

@@ -0,0 +1,61 @@
+module Locomotive
+  class ThemeAssetPresenter < BasePresenter
+
+    ## properties ##
+
+    properties  :content_type, :folder, :checksum
+    property    :plain_text,    allow_nil: false, description: 'Only returned after an update'
+
+    with_options only_setter: true do |presenter|
+      presenter.properties :plain_text_name, :plain_text_type, :performing_plain_text, :source
+    end
+
+    with_options only_getter: true do |presenter|
+      presenter.properties :local_path, :url, :size, :raw_size, :dimensions, :can_be_deleted
+    end
+
+    ## other getters / setters ##
+
+    def local_path
+      self.__source.local_path(true)
+    end
+
+    def url
+      self.__source.source.url
+    end
+
+    def size
+      number_to_human_size(self.__source.size)
+    end
+
+    def raw_size
+      self.__source.size
+    end
+
+    def dimensions
+      self.__source.image? ? "#{self.__source.width}px x #{self.__source.height}px" : nil
+    end
+
+    def updated_at
+      I18n.l(self.__source.updated_at, format: :short)
+    end
+
+    def can_be_deleted
+      self.__policy.try(:destroy?)
+    end
+
+    def plain_text
+      plain_text? ? self.__source.plain_text : nil
+    end
+
+    ## methods ##
+
+    protected
+
+    def plain_text?
+      # FIXME: self.__options contains all the options passed by the responder
+      self.__options[:template] == 'update' && self.__source.errors.empty? && self.__source.stylesheet_or_javascript?
+    end
+
+  end
+end

data/app/presenters/locomotive/translation_presenter.rb

@@ -0,0 +1,9 @@
+module Locomotive
+  class TranslationPresenter < BasePresenter
+
+    ## properties ##
+
+    properties :key, :values
+
+  end
+end

data/app/services/locomotive/content_asset_service.rb

@@ -0,0 +1,22 @@
+module Locomotive
+  class ContentAssetService < Struct.new(:site)
+
+    def list(options = {})
+      options[:per_page] ||= Locomotive.config.ui[:per_page]
+
+      site.content_assets
+        .ordered
+        .by_content_types(options[:types])
+        .by_filename(options[:query])
+        .page(options[:page] || 1).per(options[:per_page])
+    end
+
+    def bulk_create(list)
+      list = list.values if list.is_a?(Hash)
+      list.map do |params|
+        site.content_assets.create(params)
+      end
+    end
+
+  end
+end

data/app/services/locomotive/content_entry_service.rb

@@ -0,0 +1,175 @@
+module Locomotive
+  class ContentEntryService < Struct.new(:content_type, :account)
+
+    # List all the entries of a content type.
+    #
+    # If the content type allows the pagination, in other words, if the entries are not
+    # ordered by the position column), then this method will return
+    # a paginated list of entries.
+    #
+    # This list can also be filtered by the _label attribute, by setting the "q" key in the options.
+    #
+    # For a more powerful search, you can use the "where" key which accepts a JSON string or a Hash.
+    #
+    # @param [ Hash ] options The options for the pagination and the filtering
+    #
+    # @return [ Object ] a paginated list of content entries
+    #
+    def all(options = {})
+      _options = prepare_options_for_all(options)
+
+      content_type.ordered_entries(_options)
+    end
+
+    # Sort the entries of a content type.
+    #
+    # @param [ Array ] ids Ordered list of content entry ids.
+    #
+    def sort(ids)
+      klass = self.content_type.klass_with_custom_fields(:entries)
+      klass.sort_entries!(ids, self.content_type.sortable_column)
+    end
+
+    # Create a content entry from the attributes passed in parameter.
+    # It sets the created_by column with the current account.
+    #
+    # @param [ Hash ] attributes The attributes of new content entry.
+    #
+    # @return [ Object ] An instance of the content entry.
+    #
+    def create(attributes)
+      sanitize_attributes!(attributes)
+
+      content_type.entries.build(attributes).tap do |entry|
+        entry.created_by = account if account
+        entry.save
+      end
+    end
+
+    # Create a content entry from the attributes passed in parameter.
+    # It does not set the created_by column since it's called
+    # from the public side of the site with no logged in account.
+    # The attributes are filtered through the corresponding presenter.
+    #
+    # @param [ Hash ] attributes The attributes of new content entry.
+    #
+    # @return [ Object ] An instance of the content entry.
+    #
+    def public_create(attributes)
+      content_type.entries.build.tap do |entry|
+        entry.from_presenter(attributes)
+        entry.save
+      end
+    end
+
+    # Update a content entry from the attributes passed in parameter.
+    # It sets the updated_by column with the current account.
+    #
+    # @param [ Object ] entry The content entry to update.
+    # @param [ Hash ] attributes The attributes of new content entry.
+    #
+    # @return [ Object ] The instance of the content entry.
+    #
+    def update(entry, attributes)
+      sanitize_attributes!(attributes)
+
+      entry.tap do |entry|
+        entry.attributes = attributes
+        entry.updated_by = account
+        entry.save
+      end
+    end
+
+    # Destroy all the entries of a content type.
+    # Runs each entry's destroy callbacks.
+    #
+    def destroy_all
+      content_type.entries.destroy_all
+    end
+
+    # Give the list of permitted attributes for a content entry.
+    # It includes:
+    # - the default ones (_slug, seo, ...etc)
+    # - the dynamic simple attributes (strings, texts, dates, belongs_to, ...etc)
+    # - the relationships (has_many + many_to_many)
+    #
+    # @return [ Array ] List of permitted attributes
+    #
+    def permitted_attributes
+      # needed to get the custom fields
+      _entry = content_type.entries.build
+
+      default     = %w(_slug _position _visible seo_title meta_keywords meta_description)
+      dynamic     = _entry.custom_fields_safe_setters
+      referenced  = {}
+
+      # has_many
+      has_many = _entry.has_many_custom_fields.each do |n, inverse_of|
+        referenced["#{n}_attributes"] = [:_id, :_destroy, :"position_in_#{inverse_of}"]
+      end
+
+      # many_to_many
+      many_to_many = _entry.many_to_many_custom_fields.each do |(_, s)|
+        referenced[s] = []
+      end
+
+      (default + dynamic + [referenced.empty? ? nil : referenced]).compact
+    end
+
+    protected
+
+    def sanitize_attributes!(attributes)
+      # needed to get the custom fields
+      _entry = content_type.entries.build
+
+      # if the user deletes all the entries of a many_to_many field,
+      # make sure the list gets empty instead of nil.
+      _entry.many_to_many_custom_fields.each do |(_, s)|
+        attributes[s] = [] unless attributes.has_key?(s)
+      end
+    end
+
+    def prepare_options_for_all(options)
+      where = prepare_where_statement(options)
+
+      {
+        page:           options[:page] || 1,
+        per_page:       options[:per_page] || Locomotive.config.ui[:per_page],
+        where:          where
+      }.tap do |_options|
+        _options[:order_by] = options[:order_by] if options[:order_by]
+      end
+    end
+
+    def prepare_where_statement(options)
+      where = (case options[:where]
+      when String then options[:where].blank? ? {} : JSON.parse(options[:where])
+      when Hash   then options[:where]
+      else {}
+      end).with_indifferent_access
+
+      if options[:q]
+        where.merge!(prepare_query_statement(options[:q]))
+      end
+
+      where
+    end
+
+    def prepare_query_statement(query)
+      regexp  = /.*#{query.split.map { |q| Regexp.escape(q) }.join('.*')}.*/i
+
+      {}.tap do |where|
+        if self.content_type.filter_fields.blank?
+          where[content_type.label_field_name.to_sym] = regexp
+        else
+          where['$or'] = []
+          self.content_type.filter_fields.each do |field_id|
+            field = self.content_type.entries_custom_fields.find(field_id)
+            where['$or'] << { field.name => regexp }
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/services/locomotive/content_type_service.rb

@@ -0,0 +1,15 @@
+module Locomotive
+  class ContentTypeService < Struct.new(:site)
+
+    def list
+      site.content_types
+        .only(:_id, :name, :slug, :number_of_entries)
+        .order_by(:name.asc).to_a
+    end
+
+    def find_by_slug(slug)
+      site.content_types.by_id_or_slug(slug)
+    end
+
+  end
+end

data/app/services/locomotive/custom_field_finder_service.rb

@@ -0,0 +1,8 @@
+module Locomotive
+  class CustomFieldFinderService < Struct.new(:content_type)
+
+    delegate :custom_field, to: :content_type
+    delegate :find_by_name, to: :custom_field
+
+  end
+end

data/app/services/locomotive/custom_field_service.rb

@@ -0,0 +1,26 @@
+module Locomotive
+  class CustomFieldService < Struct.new(:field)
+
+    # Update the options of a "select" field.
+    #
+    # @param [ Hash ] options It includes the following keys: name, _id and _destroyed (if persisted)
+    #
+    # @return [ Array ] The new list of options
+    #
+    def update_select_options(options)
+      return nil if options.blank?
+
+      # set the right position
+      options.each_with_index do |option, position|
+        option['position'] = position
+      end
+
+      self.field.select_options_attributes = options
+
+      self.field.save
+
+      self.field.select_options
+    end
+
+  end
+end

data/app/services/locomotive/membership_service.rb

@@ -0,0 +1,45 @@
+module Locomotive
+  class MembershipService < Struct.new(:site, :policy)
+
+    # Create a new membership for the site assigned to that service.
+    # In case, no account is found from the email passed in parameter,
+    # this method will return nil.
+    # By default, the author role will be set to the new membership.
+    #
+    # @param [ String ] email The email
+    #
+    # @return [ Object ] A new membership (with errors or not) or nil (no account found)
+    #
+    def create(email)
+      if account = Locomotive::Account.find_by_email(email)
+        site.memberships.create(account: account, email: email)
+      else
+        nil
+      end
+    end
+
+    # Change the role of a membership depending on the current policy.
+    #
+    # Accounts should not be able to set the role of another account to
+    # be higher than their own.
+    # A designer for example is not able to set another account to
+    # be an administrator.
+    #
+    # @param [ String ] membership The membership to update
+    # @param [ String ] role The new role
+    #
+    # @return [ Boolean] True if everything went well
+    #
+    def change_role(membership, role)
+      membership.role = role if role.present?
+
+      if role.present? && policy.change_role?
+        membership.save
+      else
+        membership.errors.add(:role, :invalid)
+        false
+      end
+    end
+
+  end
+end

data/app/services/locomotive/page_parsing_service.rb

@@ -0,0 +1,67 @@
+module Locomotive
+
+  class PageParsingService < Struct.new(:site)
+
+    def find_or_create_editable_elements(page, locale)
+      [].tap do |elements|
+        ActiveSupport::Notifications.subscribe(/^steam\.parse\.editable\./) do |name, start, finish, id, payload|
+          current_page, attributes = payload[:page], payload[:attributes]
+
+          elements << [current_page, attributes]
+        end
+
+        parse(page, locale)
+
+        persist_editable_elements(page, elements)
+      end
+    end
+
+    private
+
+    def persist_editable_elements(page, elements)
+      elements.each do |(current_page, attributes)|
+        next unless can_persist_element?(page, current_page, attributes)
+
+        # update the element or or add the element to that page
+        if element = page.editable_elements.by_block_and_slug(attributes[:block], attributes[:slug]).first
+          element.attributes = attributes
+        else
+          element = page.editable_elements.build(attributes)
+        end
+      end
+
+      page.save!
+    end
+
+    # Fixed editable elements are not added to the parsed page unless
+    # they are defined in that page.
+    #
+    # @param [ Object ] page The page we are parsing
+    # @param [ Object ] current_page The page where the editable element were found
+    # @param [ Object ] attributes The attributes of the editable element
+    #
+    def can_persist_element?(page, current_page, attributes)
+      !attributes[:fixed] || (attributes[:fixed] && page._id == current_page._id)
+    end
+
+    def parse(page, locale)
+      entity = repository.build(page.attributes)
+      decorated_page = Locomotive::Steam::Decorators::TemplateDecorator.new(entity, locale)
+
+      parser = services.liquid_parser
+      parser.parse(decorated_page)
+    end
+
+    def services
+      @services ||= Locomotive::Steam::Services.build_instance.tap do |services|
+        services.set_site(self.site)
+      end
+    end
+
+    def repository
+      services.repositories.page
+    end
+
+  end
+
+end