infopark_rails_connector 6.8.0.beta.200.621.4c8e1b0

data/app/controllers/search_controller.rb

@@ -0,0 +1,2 @@
+class SearchController < RailsConnector::DefaultSearchController
+end

data/app/controllers/seo_sitemap_controller.rb

@@ -0,0 +1,12 @@
+# Renders a search engine optimized sitemap.xml
+# Enable via <tt>RailsConnector::Configuration.enable(:seo_sitemap)</tt>
+class SeoSitemapController < ApplicationController
+  layout nil
+
+  # Finds all objects which are to be shown in the SEO sitemap. Responds to xml only.
+  def show
+    @objects = Obj.find_all_for_sitemap
+    respond_to { |format| format.xml }
+  end
+
+end

data/app/controllers/user_controller.rb

@@ -0,0 +1,2 @@
+class UserController < RailsConnector::DefaultUserController
+end

data/app/helpers/cms_helper.rb

@@ -0,0 +1,6 @@
+# CmsHelper is a wrapper around RailsConnector::DefaultCmsHelper.
+# It can be replaced in your application in order to add or
+# modify helpers.
+module CmsHelper
+  include RailsConnector::DefaultCmsHelper
+end

data/app/helpers/cms_routing_helper.rb

@@ -0,0 +1,6 @@
+# CmsRoutingHelper is a wrapper around RailsConnector::DefaultCmsRoutingHelper.
+# It can be replaced in your application in order to add or
+# modify helpers.
+module CmsRoutingHelper
+  include RailsConnector::DefaultCmsRoutingHelper
+end

data/app/helpers/crm_form_helper.rb

@@ -0,0 +1,3 @@
+module CrmFormHelper
+  include RailsConnector::DefaultCrmFormHelper
+end

data/app/helpers/rails_connector/cms_asset_helper.rb

@@ -0,0 +1,51 @@
+module RailsConnector
+
+  # This module contains helpers that can be used to reference images and other assets stored in the CMS.
+  #
+  # Use this helper to take advantage of rails' asset host mechanism.
+  # (See http://api.rubyonrails.com/classes/ActionView/Helpers/AssetTagHelper.html for details about asset hosts.)
+  # If your application does not use any asset hosts, the helper will generate regular (=non asset host) pathes.
+  module CmsAssetHelper
+
+    # Returns an html image tag for an image stored in the CMS.
+    #
+    # +target+ is the image from the cms to be referenced in the image tag.
+    # +target+ can be an +Obj+ or a +Link+ or a +LinkList+.
+    # +options+ can be used to specify additional html attributes for the tag.
+    # If you do not specify an html alt attribute, the helper method will use
+    # +target+'s +display_title+ as the html alt attribute.
+    # If your application is configured to use asset hosts, the images tag will reference
+    # the image using one of your asset hosts.
+    def cms_image_tag(target, options = {})
+      options.symbolize_keys!
+
+      options[:src] = cms_asset_path(target)
+      options[:alt] ||= display_title(target)
+
+      tag("img", options)
+    end
+
+    # Calculate the path to an asset stored in the CMS.
+    #
+    # The path can be used to reference a cms object inside an html page.
+    # +target+ can be an +Obj+ or a +Link+ or a +LinkList+.
+    # If your application is configured to use asset hosts, the path will reference
+    # the object using one of your asset hosts.
+    def cms_asset_path(target)
+      regular_path = cms_path(target)
+      return regular_path if regular_path.first == "#"
+      asset_paths.compute_public_path(regular_path, nil)
+    end
+
+    private
+
+    def display_title(target)
+      if target.respond_to?(:display_title)
+        return target.display_title
+      elsif target.respond_to?(:first) && target.first.respond_to?(:display_title)
+        return target.first.display_title
+      end
+    end
+
+  end
+end

data/app/helpers/rails_connector/default_cms_helper.rb

@@ -0,0 +1,27 @@
+module RailsConnector
+
+  # This is a wrapper module for the default set of Rails Connector helper modules.
+  #
+  # To make autoloading from +CmsController+ work, this module must be wrapped
+  # by a module named +CmsHelper+:
+  #
+  #   module CmsHelper
+  #     include RailsConnector::DefaultCmsHelper
+  #   end
+
+  module DefaultCmsHelper
+    include DisplayHelper
+    include MarkerHelper
+    include CmsAssetHelper
+    include SeoHelper
+    include RailsConnector::MenuHelper
+    include RailsConnector::MicronavHelper
+    include RailsConnector::TimeMachineHelper
+    include RailsConnector::LinkHelper
+    include RailsConnector::CmsAssetHelper
+    include RailsConnector::TableOfContentsHelper
+    include RatingsHelper
+    include RailsConnector::LayoutHelper
+  end
+
+end

data/app/helpers/rails_connector/default_cms_routing_helper.rb

@@ -0,0 +1,93 @@
+module RailsConnector
+
+  module DefaultCmsRoutingHelper
+    # Returns the path for +target+ using the +CmsController+ routes.
+    # +target+ can be an +Obj+ or a +Link+ or a +LinkList+.
+    # If +target+ is a +Linklist+, it must be non-empty. The first +Link+ from the +LinkList+ will be used.
+    # +options+ are optional and include url settings such as path parameters or protocol
+    # +options+ are only passed on if +target+ is an +Obj+.
+    def cms_path(target, options = {})
+      cms_path_or_url(target, "path", options)
+    end
+
+    # Returns the absolute URL for target using the +CmsController+ routes.
+    # +target+ can be an +Obj+ or a +Link+ or a +LinkList+.
+    # If +target+ is a +Linklist+, it must be non-empty. The first +Link+ from the +LinkList+ will be used.
+    # +options+ are optional and include url settings such as path parameters or protocol
+    # +options+ are only passed on if +target+ is an +Obj+.
+    def cms_url(target, options = {})
+      cms_path_or_url(target, "url", options)
+    end
+
+    LINK_TO_UNRELEASED = "#__target_object_not_released" #:nodoc:
+    LINK_TO_EMPTY_LINKLIST = "#__empty_linklist" #:nodoc:
+
+    def cms_path_or_url(target, path_or_url, options = {}) #:nodoc:
+      if target.is_a?(Link)
+        cms_path_or_url_for_links(target, path_or_url)
+      elsif target.is_a?(Obj)
+        cms_path_or_url_for_objs(target, path_or_url, options)
+      elsif target.respond_to?(:first)
+        if target.first.is_a?(Link)
+          cms_path_or_url_for_links(target.first, path_or_url)
+        else
+          return LINK_TO_EMPTY_LINKLIST
+        end
+      else
+        raise "cms_path or cms_url was called with an instance of #{target.class}. "+
+          "It must only be called with an Obj or a Link or a non-empty LinkList."
+      end
+    end
+
+    def cms_path_or_url_for_links(link, path_or_url) #:nodoc:
+      return LINK_TO_UNRELEASED if link.internal? && link.destination_object.nil?
+      append_search_and_fragment(
+        basic_url_or_path_for_link(link, path_or_url), link
+      )
+    end
+
+    def cms_path_or_url_for_objs(obj, path_or_url, options = {}) #:nodoc:
+      permalink = obj.permalink
+      if permalink && !Configuration.editor_interface_enabled?
+        __send__("cms_permalink_#{path_or_url}", options.merge(:permalink => permalink))
+      elsif obj.homepage? && !Configuration.editor_interface_enabled?
+        __send__("root_#{path_or_url}", options)
+      else
+        if obj.body_data_url
+          obj.body_data_url
+        elsif obj.binary? && !obj.file_extension.blank?
+          __send__("cms_id_#{path_or_url}",
+            options.merge(:id => obj.id, :name => obj.name, :format => obj.file_extension))
+        else
+          routing_options = options.merge(:id => obj.id, :name => obj.name.presence)
+          __send__("cms_id_#{path_or_url}", routing_options)
+        end
+      end
+    end
+
+    private
+
+    def basic_url_or_path_for_link(link, path_or_url)
+      if link.internal?
+        __send__("cms_#{path_or_url}", link.destination_object)
+      else
+        if link.external_prefix?
+           remove_external_prefix(link.url)
+        else
+          link.url
+        end
+      end
+    end
+
+    def remove_external_prefix(link)
+      link.gsub(/external:/, "").strip
+    end
+
+    def append_search_and_fragment(url,link)
+      result = url
+      result += "?#{link.search}" unless link.search.blank?
+      result += "##{link.fragment}" unless link.fragment.blank?
+      result
+    end
+  end
+end

data/app/helpers/rails_connector/default_crm_form_helper.rb

@@ -0,0 +1,58 @@
+module RailsConnector
+
+  module DefaultCrmFormHelper
+
+    include ::RailsConnector::DefaultUserHelper
+    include ::RailsConnector::MandatoryLabelHelper
+    include ::RailsConnector::ErrorMessagesHelper
+
+    def custom_fields_for(form)
+      activity = instance_variable_get("@#{form.object_name}")
+      custom_attribute_defs = Infopark::Crm::CustomType.find(activity.kind).custom_attributes
+      content = "".html_safe
+      custom_attribute_defs.each do |attribute|
+        custom_attr = "custom_#{attribute.name}"
+        next unless allow_custom_attribute?(custom_attr)
+        value = activity.__send__(custom_attr).to_s
+        input_field =
+          case attribute.type
+          when 'enum'
+            form.select(custom_attr, [''] + attribute.valid_values, :value => value)
+          when 'text'
+            form.text_area(custom_attr, :value => value, :cols => 50, :rows => 5)
+          else
+            form.text_field(custom_attr, :value => value, :size => "40")
+          end
+        content << content_tag(:div, :class => 'label') do
+          if attribute.mandatory
+            mandatory_label_for(form, custom_attr, h(attribute.title))
+          else
+            form.label(custom_attr, h(attribute.title))
+          end
+        end
+        content << content_tag(:div, input_field, :class => 'field')
+      end
+      content
+    end
+
+    def title_field_for(form)
+      content = "".html_safe
+      if has_title_input_field?
+        content << content_tag(:div, :class => 'label') do
+          mandatory_label_for(form, :title, t(:"rails_connector.views.crm_form.title"))
+        end
+        content << content_tag(:div, :class => 'field') do
+          form.text_field :title
+        end
+      end
+      content
+    end
+
+    def logged_in_as(user)
+      content_tag(:em) do
+        t('rails_connector.views.crm_form.logged_in_as',
+            :user => content_tag(:strong, user)).html_safe
+      end
+    end
+  end
+end

data/app/helpers/rails_connector/default_ratings_helper.rb

@@ -0,0 +1,38 @@
+module RailsConnector
+  #
+  # This helper provides methods for use with ratings.
+  module DefaultRatingsHelper
+    # Determines whether the current user has rated a CMS object.
+    def rated_by_current_user?(obj)
+      session[:rated_objs] && session[:rated_objs][obj.id]
+    end
+
+    # Builds the HTML markup for the ratings section.
+    def stars_for_rating(obj)
+      stars = "".html_safe
+      (Rating::MINIMUM..Rating::MAXIMUM).collect do |score|
+        stars << content_tag(:li, link_a_star(score, obj))
+      end
+      stars
+    end
+
+    private
+
+    def link_a_star(score, obj)
+      css_classes = ["", "one-star", "two-stars", "three-stars", "four-stars", "five-stars"]
+      descriptions = ["",
+        t(:"rails_connector.helpers.ratings.bad"),
+        t(:"rails_connector.helpers.ratings.mediocre"),
+        t(:"rails_connector.helpers.ratings.average"),
+        t(:"rails_connector.helpers.ratings.good"),
+        t(:"rails_connector.helpers.ratings.very_good")
+      ]
+      html_options = {
+        :title => "#{score} von #{Rating::MAXIMUM} Sternen",
+        :class => css_classes[score],
+        "data-description" => descriptions[score]
+      }
+      link_to(score.to_s, ratings_url(:action => :rate, :id => obj.id, :score => score), html_options)
+    end
+  end
+end

data/app/helpers/rails_connector/default_user_helper.rb

@@ -0,0 +1,90 @@
+require "recaptcha"
+
+module RailsConnector
+
+  # This module contains helpers for the +UserController+ and +DefaultUserController+
+  module DefaultUserHelper
+
+    include ::ReCaptcha::ViewHelper
+    include ::RailsConnector::MandatoryLabelHelper
+    include ::RailsConnector::ErrorMessagesHelper
+
+    # Returns mandatory user fields as array of symbols.
+    def mandatory_user_fields
+      [:email, :gender, :language, :last_name]
+    end
+
+    # Generates part of a form for the given attributes:
+    #
+    # In your view, use:
+    #
+    #   <%= form_for @user, :as => :user do |f| -%>
+    #     <%= user_fields_for(f, 'contact', :first_name, :last_name) %>
+    #   <% end -%>
+    #
+    # to generate labels and fields for the contact:
+    #
+    #   <form>
+    #     <div class="label"><label for="user_first_name">First name</label></div>
+    #     <div class="field"><input id="user_first_name" name="user[first_name]" size="30" type="text" /></div>
+    #     <div class="label"><label for="user_last_name">Last name</label></div>
+    #     <div class="field"><input id="user_last_name" name="user[last_name]" size="30" type="text" /></div>
+    #   </form>
+    #
+    # Labels are localized automatically, using the scope views.contact and views.location,
+    # respectively. For example:
+    #
+    #   views:
+    #     user:
+    #       first_name: First name
+    #       last_name: Last name
+    def user_fields_for(form, model_name, *attributes)
+      output = "".html_safe
+      attributes.flatten.each do |attr|
+        output += content_tag(:div, :class => 'label') do
+          if mandatory_user_fields.include?(attr)
+            mandatory_label_for(form, attr, t("rails_connector.views.user.#{model_name}.#{attr}"))
+          else
+            form.label(attr, t("rails_connector.views.user.#{model_name}.#{attr}"))
+          end
+        end
+        form_field = case attr
+          when :gender
+            form.select(:gender, genders_for_select)
+          when :language
+            languages = Infopark::Crm::CustomType.find('contact').languages
+            form.select(:language, languages_for_select_for(languages),
+                :selected => (@user ? @user.language : I18n.locale.to_s) )
+          else
+            form.text_field(attr)
+          end
+        output += content_tag(:div, form_field, :class => 'field')
+      end
+      output
+    end
+
+    def genders_for_select
+      [
+        ['', 'N'],
+        [t('rails_connector.views.user.gender_female'),'F'],
+        [t('rails_connector.views.user.gender_male'), 'M']
+      ]
+    end
+
+    def languages_for_select_for(*languages)
+      options = []
+      languages.flatten.each do |lang|
+        options << [t(:"rails_connector.views.user.languages.#{lang}"), lang]
+      end
+      options
+    end
+
+    def profile_fields_for(form, editable_attributes={})
+      output = "".html_safe
+      output += user_fields_for(form, "contact", editable_attributes[:contact])
+      output
+    end
+
+  end
+
+end

data/app/helpers/rails_connector/display_helper.rb

@@ -0,0 +1,117 @@
+module RailsConnector
+
+  # This module contains a helper that can be used to render attributes of the CMS models.
+  module DisplayHelper
+
+    # For a consistent look of your site and easy maintenance, only the display helpers
+    # should be used to render an attribute <em>value</em> of a CMS model.
+    #
+    #   <%= display_value @obj.title %>
+    # Renders the value, taking its type into account.
+    # * An HtmlString will be exported by converting its links
+    # * A Time will be exported in an international form: Year-Mounth-Day Hour:Minutes
+    # * A non-HTML String will be quoted
+    # * other values will be rendered unchanged
+    #
+    def display_value(value)
+      case value
+        when MarkdownString then markdown(convert_links(value)).html_safe
+        when HtmlString then convert_links(value).html_safe
+        when String then h(value)
+        when Time then h(l(value))
+        else value
+      end
+    end
+
+    # Renders a field from the CMS, including an edit marker for the preview
+    # If the option :marker is false, no edit marker will be rendered.
+    #
+    # <%= display_field @obj, :title %>
+    #
+    # When creating an edit marker, all options except :marker are passed to MarkerHelper::edit_marker.
+    #
+    def display_field(obj, attr, options = {})
+      options.reverse_merge!({
+        :marker => ![:id, :path, :created, :last_changed, :version].include?(attr.to_sym)
+        })
+      if options.delete :marker
+        edit_marker(obj, attr, options) do |obj, attr|
+          display_value obj[attr]
+        end
+      else
+        display_value obj[attr]
+      end
+    end
+
+    # Legacy method - deprecated
+    #
+    # Use display_value and display_field instead
+    #
+    def display(*args) #:nodoc:
+      if args.last.kind_of? Hash
+        options = args.pop
+      else
+        options = {}
+      end
+      return display_value(args.first) if args.size == 1
+      display_field(args[0], args[1], options)
+    end
+
+    private
+
+    def markdown(string)
+      require 'maruku'
+      Maruku.new(string).to_html
+    end
+
+    LINK_PATTERN = '<?\binternallink:(\d+)\b>?'
+    LINK_EXPRESSION = %r(#{LINK_PATTERN})
+
+    def convert_links(content_attribute)
+      return content_attribute unless content_attribute =~ LINK_EXPRESSION
+      link_map = content_attribute.source.text_links.each_with_object({}) do |link, map|
+        map[link.id.to_s] = link
+      end
+      content_attribute.gsub(%r(#{LINK_PATTERN}(['"]?))) do
+        link = link_map[$1.to_s]
+        if link.blank?
+          "#{CmsRoutingHelper::LINK_TO_UNRELEASED}#{$2}"
+        else
+          uri = "#{cms_path(link)}#{$2}"
+          if link.markdown?
+            markdown_link(link, uri)
+          else
+            html_link(link, uri)
+          end
+        end
+      end
+    end
+
+    def html_link(link, uri)
+      subst = uri
+      name, value =
+          case link.tag_name
+          when 'img', 'input'
+            ['alt', link.title || ""]
+          when 'a', 'link'
+            ['title', begin link.title unless link.title.blank? end]
+          end
+      if value
+        subst << %( #{name}="#{h(value)}")
+      end
+      subst << %( target="#{h(link.target)}") unless link.target.blank?
+      subst
+    end
+
+    def markdown_link(link, uri)
+      subst = "<#{uri}>"
+      unless link.title.blank?
+        case link.markdown_type
+        when 'inline', 'reference'
+          subst << %( "#{h(link.title)}")
+        end
+      end
+      subst
+    end
+  end
+end

data/app/helpers/rails_connector/error_messages_helper.rb

@@ -0,0 +1,23 @@
+module RailsConnector
+  module ErrorMessagesHelper
+    # Shortened error_messages_for from git://github.com/rails/dynamic_form.git
+    def error_messages(*objects)
+      objects.compact!
+      count = objects.inject(0) {|sum, object| sum + object.errors.count }
+      return '' if count.zero?
+
+      content_tag(:div, :class => 'errorExplanation') do
+        c = ''.html_safe
+        c << content_tag(:ul) do
+          li = ''.html_safe
+          objects.each do |object|
+            object.errors.full_messages.each do |msg|
+              li << content_tag(:li, msg)
+            end
+          end
+          li
+        end
+      end
+    end
+  end
+end

data/app/helpers/rails_connector/layout_helper.rb

@@ -0,0 +1,30 @@
+module RailsConnector
+
+  # This module contains helpers that render tags for the html head
+  # and the end of the html body.
+  module LayoutHelper
+    include TrackingHelper
+
+    # Renders all tags needed in the html head for the enabled features.
+    def rails_connector_header_tags
+      html = "".html_safe
+      html += tag('meta', :name => 'generator',
+          :content => "Rails Connector for Infopark CMS Fiona by Infopark AG (www.infopark.de); "\
+          "Version #{Gem.loaded_specs['infopark_rails_connector'].version}")
+      if Configuration.enabled?(:rss)
+        html += auto_discovery_link_tag(:rss, rss_url, :title => 'RSS Feed')
+      end
+      html += include_edit_marker_support
+      html
+    end
+
+    # Renders all tags needed at the end of the body tag for the enabled features.
+    def rails_connector_after_content_tags
+      html = "".html_safe
+      html += render_marker_code
+      html += google_analytics if Configuration.enabled?(:google_analytics)
+      html
+    end
+  end
+
+end

data/app/helpers/rails_connector/link_helper.rb

@@ -0,0 +1,88 @@
+require "uri"
+
+module RailsConnector
+
+  # This module contains a helper that can be used to build markup for a link, e.g. a download link.
+  module LinkHelper
+    # Generates a link by producing the corresponding HTML markup.
+    # <em>link</em> is the Link to be rendered, you may specify the following <em>options</em>:
+    #
+    # [:file_extension] specifies the file extension if the link object is an internal link.
+    # An external link has no file extension since there is no destination object from which
+    # the file extension could be taken. File extensions are, for example, 'pdf', 'zip', or 'doc'.
+    #
+    # The HTML text generated depends on the kind of Link passed to the helper:
+    #
+    #   <%= link(@myLinkObject) %>
+    #
+    # [With an internal Link] The helper will produce the following HTML where path is
+    # the path created by the PageHelper, file extension is the file_extension of the
+    # destination object. For a Content, the display title is the Link's display_title and
+    # size is the size of its body (in KB or MB):
+    #   <a href='path' class='link'>
+    #     <span class='file extension'>
+    #     display title
+    #     <span class='link_size'> (size)</span>
+    #     </span>
+    #   </a></tt>
+    #
+    # [With an external Link] The helper will produce the following HTML where url
+    # is the external url of the link and display title is the display_title of the Link:
+    #
+    #   <a class='link' href='url'>
+    #     <span>display title</span>
+    #   </a>
+    #
+    # Normally, you do not know the file extension of the external source, so by default
+    # there will be no CSS class generated for the nested <tt><span></tt> tag. In the case
+    # that you do know it or want some external links to have a special style, you can
+    # specify the file extension with the :file_extension option:
+    #
+    #   <%= link(@myLinkObject, :file_extension => 'file_extension' %>
+    #
+    # The helper would then produce the following:
+    #
+    #   <a class='link' href='destination'>
+    #     <span class='file_extension'>title</span>
+    #   </a>
+    def link(link, options = {})
+      link_attributes = {
+        :href => cms_path(link),
+        :class => 'link'
+      }
+      link_attributes[:target] = link.target unless link.target.blank?
+      content_tag(:a,
+        content_tag(:span,
+          display_value(link.display_title) + size_content(link),
+          :class => options[:file_extension] || link.file_extension
+        ),
+        link_attributes
+      )
+    end
+
+    # Displays a link list as an HTML list.
+    # <em>link_list</em> is the link list to be rendered. For each link #link is called.
+    # For a list of valid <em>options</em> see #link.
+    #
+    # The generated list element has the CSS class 'linklist'.
+    def link_list(link_list, options = {})
+      return if link_list.blank?
+      markup = "<ul class='linklist'>"
+      link_list.each do |l|
+        markup << "<li>#{link l, options}</li>"
+      end
+      markup << "</ul>"
+    end
+
+    private
+
+    def size_content(link)
+      return "" unless link.internal? && link.destination_object && link.destination_object.binary?
+      size = ' (' + number_to_human_size(link.destination_object.body_length) + ')'
+      content_tag(:span, size, :class => 'link_size')
+    end
+
+    include DisplayHelper
+  end
+
+end

data/app/helpers/rails_connector/mandatory_label_helper.rb

@@ -0,0 +1,10 @@
+module RailsConnector
+  module MandatoryLabelHelper
+    def mandatory_label_for(form, object, label)
+      html = "".html_safe
+      html += label
+      html += content_tag(:span, " *", :class => "mandatory_star")
+      form.label(object, html, :class => "mandatory")
+    end
+  end
+end