locomotivecms_steam 1.1.2 → 1.2.0.beta1

data/lib/locomotive/steam/middlewares/helpers.rb

@@ -37,6 +37,14 @@ module Locomotive::Steam
         path
       end
 
+      # make sure the location passed in parameter doesn't
+      # include the "mounted_on" parameter.
+      # If so, returns the location without the "mounted_on" string.
+      def make_local_path(location)
+        return location if mounted_on.blank?
+        location.gsub(Regexp.new('^' + mounted_on), '')
+      end
+
       def mounted_on
         request.env['steam.mounted_on']
       end

data/lib/locomotive/steam/middlewares/locale.rb

@@ -28,7 +28,7 @@ module Locomotive::Steam
       protected
 
       def extract_locale
-        _locale = locale_from_params || default_locale
+        _locale = params[:locale] || default_locale
         _path   = request.path_info
 
         if _path =~ /^\/(#{site.locales.join('|')})+(\/|$)/
@@ -44,10 +44,6 @@ module Locomotive::Steam
         env['steam.locale'] = services.locale = _locale
       end
 
-      def locale_from_params
-        locales.include?(params[:locale]) ? params[:locale] : nil
-      end
-
     end
   end
 end

data/lib/locomotive/steam/middlewares/locale_redirection.rb

@@ -23,7 +23,7 @@ module Locomotive::Steam
           if site.prefix_default_locale
             path_with_default_locale if locale_not_mentioned_in_path?
           else
-            path_without_default_locale if default_locale? && locale_mentioned_in_path?
+            env['steam.path'] if default_locale? && locale_mentioned_in_path?
           end
         end
       end
@@ -50,12 +50,6 @@ module Locomotive::Steam
         end
       end
 
-      def path_without_default_locale
-        modify_path do |segments|
-          segments.delete_at(1)
-        end
-      end
-
     end
   end
 

data/lib/locomotive/steam/middlewares/renderer.rb

@@ -20,7 +20,7 @@ module Locomotive::Steam
           redirect_to(page.redirect_url, page.redirect_type)
         else
           content = parse_and_render_liquid
-          render_response(content, page.not_found? ? 404 : 200, page.response_type)
+          render_response(content, page.not_found? ? 404: 200, page.response_type)
         end
       end
 
@@ -53,7 +53,8 @@ module Locomotive::Steam
           services:       services,
           repositories:   services.repositories,
           logger:         Locomotive::Common::Logger,
-          live_editing:   !!env['steam.live_editing']
+          live_editing:   !!env['steam.live_editing'],
+          session:        request.session
         }
       end
 
@@ -71,7 +72,8 @@ module Locomotive::Steam
           'now'               => Time.zone.now,
           'today'             => Date.today,
           'mode'              => Locomotive::Steam.configuration.mode,
-          'wagon'             => Locomotive::Steam.configuration.mode == :test
+          'wagon'             => Locomotive::Steam.configuration.mode == :test,
+          'live_editing'      => !!env['steam.live_editing']
         }
       end
 
@@ -102,6 +104,7 @@ module Locomotive::Steam
           'ip_address'  => request.ip,
           'post?'       => request.post?,
           'base_url'    => request.base_url,
+          'user_agent'  => request.user_agent,
           'mounted_on'  => mounted_on
         }
       end

data/lib/locomotive/steam/middlewares/site.rb

@@ -16,7 +16,8 @@ module Locomotive::Steam
         # log anyway
         log_site(site)
 
-        redirect_to_first_domain_if_enabled(site)
+        # redirect to the first domain and/or HTTPS if defined by the site
+        redirect_if_required(site)
       end
 
       private
@@ -40,9 +41,11 @@ module Locomotive::Steam
         end
       end
 
-      def redirect_to_first_domain_if_enabled(site)
-        if redirect_to_first_domain?(site)
-          klass = request.scheme == 'https' ? URI::HTTPS : URI::HTTP
+      def redirect_if_required(site)
+        return if env['steam.is_default_host']
+
+        if redirect_to_first_domain?(site) || redirect_to_https?(site)
+          klass = request.scheme == 'https' || redirect_to_https?(site) ? URI::HTTPS : URI::HTTP
           redirect_to klass.build(
             host:   site.domains.first,
             port:   [80, 443].include?(request.port) ? nil : request.port,
@@ -54,11 +57,15 @@ module Locomotive::Steam
       def redirect_to_first_domain?(site)
         # the site parameter can be an instance of Locomotive::Steam::Services::Defer and
         # so comparing just site may not be reliable.
-        !env['steam.is_default_host'] &&
         site.try(:redirect_to_first_domain) &&
         site.domains.first != request.host
       end
 
+      def redirect_to_https?(site)
+        site.try(:redirect_to_https) &&
+        request.scheme != 'https'
+      end
+
       def log_site(site)
         if site.nil?
           msg = "Unable to find a site, url asked: #{request.url} ".colorize(color: :light_white, background: :red)

data/lib/locomotive/steam/middlewares/sitemap.rb

@@ -27,8 +27,8 @@ module Locomotive::Steam
       end
 
       def build_pages_to_xml
-        repositories.page.published.map do |page|
-          next if page.index? || page.not_found?
+        page_repository.published.map do |page|
+          next if page.index? || page.not_found? || page.layout?
 
           build_page_xml(page)
         end.flatten.join.strip
@@ -80,6 +80,10 @@ module Locomotive::Steam
         services.repositories
       end
 
+      def page_repository
+        repositories.page
+      end
+
       def url_for(page, locale = nil)
         services.url_builder.url_for(page, locale)
       end

data/lib/locomotive/steam/middlewares/thread_safe.rb

@@ -53,10 +53,6 @@ module Locomotive::Steam::Middlewares
       @liquid_assigns ||= env.fetch('steam.liquid_assigns')
     end
 
-    def locales
-      site.locales
-    end
-
     def default_locale
       site.default_locale
     end

data/lib/locomotive/steam/models/associations/many_to_many.rb

@@ -6,7 +6,7 @@ module Locomotive::Steam
       def __load__
         key = @repository.k(:_id, :in)
 
-        @repository.local_conditions[key] = @entity[__target_key__]
+        @repository.local_conditions[key] = @entity[__target_key__] || []
 
         # use order_by from options as the default one for further queries
         @repository.local_conditions[:order_by] = @options[:order_by] unless @options[:order_by].blank?

data/lib/locomotive/steam/models/entity.rb

@@ -39,6 +39,11 @@ module Locomotive::Steam
         attributes[name]
       end
 
+      def change(new_attributes)
+        attributes.merge!((new_attributes || {}).with_indifferent_access)
+        self
+      end
+
       def serialize
         attributes.dup
       end

data/lib/locomotive/steam/models/repository.rb

@@ -32,6 +32,10 @@ module Locomotive::Steam
         adapter.create(mapper, scope, entity)
       end
 
+      def update(entity)
+        adapter.update(mapper, scope, entity)
+      end
+
       def inc(entity, attribute, amount = 1)
         adapter.inc(mapper, entity, attribute, amount)
       end

data/lib/locomotive/steam/repositories/content_entry_repository.rb

@@ -131,7 +131,7 @@ module Locomotive
       end
 
       def prepare_conditions(*conditions)
-        _conditions = Conditions.new(conditions.first, self.content_type.fields).prepare
+        _conditions = Conditions.new(adapter, conditions.first, self.content_type.fields).prepare
 
         super({ _visible: true }, _conditions)
       end
@@ -185,8 +185,10 @@ module Locomotive
 
       class Conditions
 
-        def initialize(conditions = {}, fields)
-          @conditions, @fields, @operators = conditions.try(:with_indifferent_access) || {}, fields, {}
+        def initialize(adapter, conditions = {}, fields)
+          @adapter    = adapter
+          @conditions = conditions.try(:with_indifferent_access) || {}
+          @fields, @operators = fields, {}
 
           @conditions.each do |name, value|
             _name, operator = name.to_s.split('.')
@@ -200,6 +202,9 @@ module Locomotive
             field.select_options.by_name(value).try(:_id)
           end
 
+          # date
+          _prepare(@fields.dates_and_date_times) { |field, value| value_to_date(value, field.type) }
+
           # belongs_to
           _prepare(@fields.belongs_to) { |field, value| value_to_id(value) }
 
@@ -233,11 +238,25 @@ module Locomotive
         end
 
         def value_to_id(value)
-          if value.respond_to?(:each) # array
+          _value = if value.is_a?(Hash)
+            value['_id'] || value[:_id]
+          elsif value.respond_to?(:each) # array
             values_to_ids(value)
           else
             value.respond_to?(:_id) ? value._id : value
           end
+
+          @adapter.make_id(_value)
+        end
+
+        def value_to_date(value, type)
+          _value = if value.is_a?(String)
+            Chronic.time_class = Time.zone
+            Chronic.parse(value)
+          else
+            value
+          end
+          type == :date ? _value.to_date : _value.to_datetime
         end
 
         def values_to_ids(value)

data/lib/locomotive/steam/repositories/content_type_field_repository.rb

@@ -26,6 +26,10 @@ module Locomotive
         query { where(type: :file) }.all
       end
 
+      def dates_and_date_times
+        query { where(k(:type, :in) => %i(date date_time)) }.all
+      end
+
       def belongs_to
         query { where(type: :belongs_to) }.all
       end

data/lib/locomotive/steam/services/action_service.rb

@@ -0,0 +1,92 @@
+# Force ExecJS to select the best engine based on the current configuration.
+# It means that if, down the road, we load a different javascript engine,
+# the ExecJS runtime won't be affected.
+require 'duktape'
+require 'execjs'
+ExecJS.runtimes.delete_if { |mod| mod.is_a?(ExecJS::DuktapeRuntime) }
+ExecJS.instance_variable_set(:@runtime, ExecJS::Runtimes.autodetect)
+
+module Locomotive
+  module Steam
+
+    class ActionService
+
+      BUILT_IN_FUNCTIONS = %w(
+        getProp
+        setProp
+        getSessionProp
+        setSessionProp
+        sendEmail
+        allEntries
+        findEntry
+        createEntry
+        updateEntry)
+
+      attr_accessor_initialize :site, :email, :content_entry_service
+
+      def run(script, params = {}, liquid_context)
+        context = Duktape::Context.new
+
+        define_built_in_functions(context, liquid_context)
+
+        script = <<-JS
+          function locomotiveAction(site, params) {
+            #{script}
+          }
+        JS
+
+        # puts script.inspect # DEBUG
+
+        context.exec_string script
+
+        context.call_prop('locomotiveAction', site.as_json, params)
+      end
+
+      private
+
+      def define_built_in_functions(context, liquid_context)
+        BUILT_IN_FUNCTIONS.each do |name|
+          context.define_function name, &send(:"#{name.underscore}_lambda", liquid_context)
+        end
+      end
+
+      def send_email_lambda(liquid_context)
+        -> (options) { !!email.send_email(options, liquid_context) }
+      end
+
+      def get_prop_lambda(liquid_context)
+        -> (name) { liquid_context[name].as_json }
+      end
+
+      def set_prop_lambda(liquid_context)
+        -> (name, value) { liquid_context.scopes.last[name] = value }
+      end
+
+      def get_session_prop_lambda(liquid_context)
+        -> (name) { liquid_context.registers[:session][name.to_sym].as_json }
+      end
+
+      def set_session_prop_lambda(liquid_context)
+        -> (name, value) { liquid_context.registers[:session][name.to_sym] = value }
+      end
+
+      def all_entries_lambda(liquid_context)
+        -> (type, conditions) { content_entry_service.all(type, conditions, true) }
+      end
+
+      def find_entry_lambda(liquid_context)
+        -> (type, id_or_slug) { content_entry_service.find(type, id_or_slug, true) }
+      end
+
+      def create_entry_lambda(liquid_context)
+        -> (type, attributes) { content_entry_service.create(type, attributes, true) }
+      end
+
+      def update_entry_lambda(liquid_context)
+        -> (type, id_or_slug, attributes) { content_entry_service.update(type, id_or_slug, attributes, true) }
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/content_entry_service.rb

@@ -0,0 +1,114 @@
+require 'sanitize'
+
+module Locomotive
+  module Steam
+
+    class ContentEntryService
+
+      include Locomotive::Steam::Services::Concerns::Decorator
+
+      attr_accessor_initialize :content_type_repository, :repository, :locale
+
+      def all(type_slug, conditions = {}, as_json = false)
+        with_repository(type_slug) do |_repository|
+          _repository.all(conditions).map do |entry|
+            _decorate(entry, as_json)
+          end
+        end
+      end
+
+      def find(type_slug, id_or_slug, as_json = false)
+        with_repository(type_slug) do |_repository|
+          entry = _repository.by_slug(id_or_slug) || _repository.find(id_or_slug)
+          _decorate(entry, as_json)
+        end
+      end
+
+      # Warning: do not work with localized and file fields
+      def create(type_slug, attributes, as_json = false)
+        with_repository(type_slug) do |_repository|
+          entry = _repository.build(clean_attributes(attributes))
+          decorated_entry = i18n_decorate { entry }
+
+          if validate(_repository, decorated_entry)
+            _repository.create(entry)
+          end
+
+          _json_decorate(decorated_entry, as_json)
+        end
+      end
+
+      # Warning: do not work with localized and file fields
+      def update(type_slug, id_or_slug, attributes, as_json = false)
+        with_repository(type_slug) do |_repository|
+          entry = _repository.by_slug(id_or_slug) || _repository.find(id_or_slug)
+          decorated_entry = i18n_decorate { entry.change(clean_attributes(attributes)) }
+
+          if validate(_repository, decorated_entry)
+            _repository.update(entry)
+          end
+
+          _json_decorate(decorated_entry, as_json)
+        end
+      end
+
+      def delete(type_slug, id_or_slug)
+        with_repository(type_slug) do |_repository|
+          entry = _repository.by_slug(id_or_slug) || _repository.find(id_or_slug)
+          _repository.delete(entry)
+        end
+      end
+
+      def get_type(slug)
+        return nil if slug.blank?
+
+        content_type_repository.by_slug(slug)
+      end
+
+      private
+
+      def with_repository(type_or_slug)
+        type = type_or_slug.respond_to?(:fields) ? type_or_slug : get_type(type_or_slug)
+
+        return if type.nil?
+
+        yield(repository.with(type))
+      end
+
+      def _decorate(entry, as_json)
+        decorated_entry = i18n_decorate { entry }
+        _json_decorate(decorated_entry, as_json)
+      end
+
+      def _json_decorate(entry, as_json)
+        as_json ? entry.as_json : entry
+      end
+
+      def clean_attributes(attributes)
+        attributes.each do |key, value|
+          next unless value.is_a?(String)
+          attributes[key] = Sanitize.clean(value, Sanitize::Config::BASIC)
+        end
+        attributes
+      end
+
+      def validate(_repository, entry)
+        # simple validations (existence of values) first
+        entry.valid?
+
+        # check if the entry has unique values for its
+        # fields marked as unique
+        content_type_repository.look_for_unique_fields(entry.content_type).each do |name, _|
+          if _repository.exists?(name => entry.send(name))
+            entry.errors.add(name, :unique)
+          end
+        end
+
+        entry.errors.empty?
+      end
+
+    end
+
+  end
+end
+

data/lib/locomotive/steam/services/email_service.rb

@@ -0,0 +1,102 @@
+require 'pony'
+
+module Locomotive
+  module Steam
+
+    class EmailService
+
+      attr_accessor_initialize :page_finder_service, :liquid_parser, :asset_host, :simulation
+
+      def send_email(options, context)
+        prepare_options(options, context)
+
+        log(options, simulation)
+
+        !simulation ? send_email!(options) : nil
+      end
+
+      def send_email!(options)
+        Pony.mail(options)
+      end
+
+      def logger
+        Locomotive::Common::Logger
+      end
+
+      private
+
+      def prepare_options(options, context)
+        build_body(options.symbolize_keys!, context, options.delete(:html))
+
+        extract_attachment(options)
+
+        options[:via] ||= :smtp
+        options[:via_options] ||= options.delete(:smtp).try(:symbolize_keys)
+      end
+
+      def build_body(options, context, html = true)
+        key = html || html.nil? ? :html_body : :body
+
+        document = (if handle = options.delete(:page_handle)
+          parse_page(handle)
+        elsif body = options.delete(:body)
+          liquid_parser.parse_string(body)
+        else
+          raise "[EmailService] the body or page_handle options are missing."
+        end)
+
+        options[key] = document.render(context)
+      end
+
+      def parse_page(handle)
+        if page = page_finder_service.by_handle(handle, false)
+          liquid_parser.parse(page) # the liquid parser decorates the page (i18n)
+        else
+          raise "[EmailService] No page found with the following handle: #{handle}"
+        end
+      end
+
+      def extract_attachment(options)
+        (options[:attachments] || {}).each do |filename, value|
+          options[:attachments][filename] = read_attachment(value)
+        end
+      end
+
+      def read_attachment(value)
+        url = case value
+        when /^https?:\/\// then value
+        when /^\//          then asset_host.compute(value, false)
+        else
+          nil
+        end
+
+        url ? _read_http_attachment(url) : value
+      end
+
+      def _read_http_attachment(url)
+        begin
+          uri = URI(url)
+          Net::HTTP.get(uri)
+        rescue Exception => e
+          logger.error "[SendEmail] Unable to read the '#{url}' url, error: #{e.message}"
+          nil
+        end
+      end
+
+      def log(options, simulation)
+        message = ["[#{simulation ? 'Test' : 'Live'}] Sent email via #{options[:via]} (#{options[:via_options].inspect}):"]
+        message << "From:     #{options[:from]}"
+        message << "To:       #{options[:to]}"
+        message << "Subject:  #{options[:subject]}"
+        message << "Attachments:  #{options[:attachments]}"
+        message << "-----------"
+        message << (options[:body] || options[:html_body]).gsub("\n", "\n\t")
+        message << "-----------"
+
+        logger.info message.join("\n") + "\n\n"
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/entry_submission_service.rb

@@ -1,76 +1,24 @@
-require 'sanitize'
-
 module Locomotive
   module Steam
 
     class EntrySubmissionService
 
-      include Locomotive::Steam::Services::Concerns::Decorator
-
-      attr_accessor_initialize :content_type_repository, :repository, :locale
+      attr_accessor_initialize :service
 
-      def submit(slug, attributes = {})
-        type = get_type(slug)
+      def submit(type_slug, attributes = {})
+        type = service.get_type(type_slug)
 
         return nil if type.nil? || type.public_submission_enabled == false
 
-        clean_attributes(attributes)
-
-        build_entry(type, attributes) do |entry|
-          if validate(entry)
-            repository.create(entry)
-          end
-        end
+        service.create(type, attributes)
       end
 
       def find(type_slug, slug)
-        type = get_type(type_slug)
-
-        return nil if type.nil?
-
-        i18n_decorate { repository.with(type).by_slug(slug) }
+        service.find(type_slug, slug)
       end
 
       def to_json(entry)
-        return nil if entry.nil?
-
-        entry.to_json
-      end
-
-      private
-
-      def get_type(slug)
-        return nil if slug.blank?
-
-        content_type_repository.by_slug(slug)
-      end
-
-      def build_entry(type, attributes, &block)
-        i18n_decorate { repository.with(type).build(attributes) }.tap do |entry|
-          yield(entry)
-        end
-      end
-
-      def validate(entry)
-        # simple validations (existence of values) first
-        entry.valid?
-
-        # check if the entry has unique values for its
-        # fields marked as unique
-        content_type_repository.look_for_unique_fields(entry.content_type).each do |name, _|
-          if repository.with(entry.content_type).exists?(name => entry.send(name))
-            entry.errors.add(name, :unique)
-          end
-        end
-
-        entry.errors.empty?
-      end
-
-      def clean_attributes(attributes)
-        attributes.each do |key, value|
-          next unless value.is_a?(String)
-          attributes[key] = Sanitize.clean(value, Sanitize::Config::BASIC)
-        end
+        entry.try(&:to_json)
       end
 
     end

data/lib/locomotive/steam/services/liquid_parser_service.rb

@@ -14,6 +14,12 @@ module Locomotive
           default_editable_content:   {})
       end
 
+      def parse_string(string)
+        Locomotive::Steam::Liquid::Template.parse(string,
+          snippet_finder: snippet_finder,
+          parser:         self)
+      end
+
       def _parse(object, options = {})
         # Note: the template must not be parsed here
         Locomotive::Steam::Liquid::Template.parse(object.liquid_source, options)